@boopkit/cli 0.3.1 → 0.4.0

package/README.md

@@ -61,7 +61,7 @@ A **capability** is a composable feature bundle. Each capability package ships:
 - **Middleware hooks** — lines wired into `src/server.ts` at the right phase (imports, pre-routes, routes, error-handling)
 - **Scripts** — added to `package.json` (e.g. `db:migrate`, `tailwind:build`)
 - **Post-install steps** — human/agent-readable instructions printed by `boop status`
-- **Agent skills** — `.skill.md` files that teach AI agents the conventions this capability uses
+- **Agent skills** — skill folders (each containing a `SKILL.md`) that teach AI agents the conventions this capability uses
 
 Capabilities can declare `requires` relationships (e.g. `users-and-accounts` requires `database`, `services`, and `web`). `boop add` resolves the dependency graph and installs everything needed.
 
@@ -138,7 +138,7 @@ Flags:
 
 Boop is built for agent-assisted work — the skills and conventions ship with the code so your agent has real guidance, not just a blank repo. Every scaffolded project includes:
 
-- **Skills** — every capability installs `.skill.md` files into `skills/`. These are focused, task-specific instructions (e.g. `design.rest-api-design.skill.md`, `test.tdd-light.skill.md`) that tell an agent the conventions this project uses.
+- **Skills** — every capability installs skill folders into `skills/`. These are focused, task-specific instructions (each folder contains a `SKILL.md`, e.g. `skills/rest-api-design/SKILL.md`, `skills/tdd-light/SKILL.md`) that tell an agent the conventions this project uses.
 - **`boop status`** — after `boop init` or `boop add`, run `boop status`. It prints every capability's post-install steps. Hand this to your agent and say "finish setup."
 - **`boop loop`** — Uses Claude for 'unattended work', building working code and UI from your specifications. 
   - `prefix` mode: Plan work as a tree of issues, then `boop loop --prefix <id>` processes them one at a time, each in its own Claude Code session. Dry-run by default; budget-capped; resumes unfinished work. See [docs/loop.md](docs/loop.md).

package/dist/capability-versions.json

@@ -1,18 +1,18 @@
 {
-  "@boopkit/cap-api": "0.3.0",
-  "@boopkit/cap-background-jobs": "0.3.0",
-  "@boopkit/cap-cloud-storage": "0.3.0",
-  "@boopkit/cap-coding": "0.3.0",
-  "@boopkit/cap-database": "0.3.0",
-  "@boopkit/cap-email": "0.3.0",
-  "@boopkit/cap-hello": "0.3.0",
-  "@boopkit/cap-noticeboard": "0.3.0",
-  "@boopkit/cap-product-design": "0.3.0",
-  "@boopkit/cap-project-mgmt": "0.3.0",
-  "@boopkit/cap-services": "0.3.0",
-  "@boopkit/cap-skills": "0.3.0",
-  "@boopkit/cap-testing": "0.3.0",
-  "@boopkit/cap-users": "0.3.0",
-  "@boopkit/cap-web": "0.3.0",
-  "@boopkit/logger": "0.3.0"
+  "@boopkit/cap-api": "0.4.0",
+  "@boopkit/cap-background-jobs": "0.4.0",
+  "@boopkit/cap-cloud-storage": "0.4.0",
+  "@boopkit/cap-coding": "0.4.0",
+  "@boopkit/cap-database": "0.4.0",
+  "@boopkit/cap-email": "0.4.0",
+  "@boopkit/cap-hello": "0.4.0",
+  "@boopkit/cap-noticeboard": "0.4.0",
+  "@boopkit/cap-product-design": "0.4.0",
+  "@boopkit/cap-project-mgmt": "0.4.0",
+  "@boopkit/cap-services": "0.4.0",
+  "@boopkit/cap-skills": "0.4.0",
+  "@boopkit/cap-testing": "0.4.0",
+  "@boopkit/cap-users": "0.4.0",
+  "@boopkit/cap-web": "0.4.0",
+  "@boopkit/logger": "0.4.0"
 }

package/dist/commands/init.js

@@ -245,6 +245,8 @@ function runInit(name, options) {
     }
     // --- Inject CSS imports for capability partials ---
     (0, scaffold_1.injectCssImports)(targetDir, cssCapMap, { skipBackup: true });
+    // --- Symlink skills/* into .claude/skills/ for Claude Code auto-discovery ---
+    (0, scaffold_1.linkSkillsToClaude)(targetDir);
     // --- Merge capability scripts into package.json ---
     if (Object.keys(allScripts).length > 0) {
         const pkgPath = path.join(targetDir, 'package.json');
@@ -263,8 +265,6 @@ function runInit(name, options) {
     if (fs.existsSync(profileRefDir)) {
         (0, safe_io_1.safeCopyDir)(profileRefDir, path.join(targetDir, 'reference'), { onConflict: 'skip' });
     }
-    // --- Generate skills index from installed skill files ---
-    (0, scaffold_1.generateSkillsIndex)(targetDir);
     // --- Build capabilityConfig for capabilities with env vars ---
     const capabilityConfig = {};
     const envEntries = [];

package/dist/commands/loop.js

@@ -332,7 +332,7 @@ ${issue.description}
 ## Instructions
 1. Read AGENTS.md for project orientation
 2. Claim the issue: bd update ${issue.id} --claim
-3. Read relevant skills from skills/index.md before making changes
+3. Read relevant skills from skills/ (list folders, read each SKILL.md) before making changes
 4. Implement the changes following TDD-Lite: observe, implement, verify
 5. Run tests if applicable: npm test
 6. Commit your changes with a message referencing ${issue.id}

package/dist/commands/status.js

@@ -181,7 +181,9 @@ async function enrichWithSetupChecks(data, envValues, projectDir, projectName) {
             label: (0, interpolate_1.interpolate)(c.label, vars),
             hint: c.hint ? (0, interpolate_1.interpolate)(c.hint, vars) : undefined,
         }));
-        const steps = await (0, db_status_1.runSetupChecks)(interpolatedChecks, envValues, projectDir, projectName);
+        // Extract this capability's .prisma files for scoped prisma-migrate checks
+        const prismaFiles = capDef?.files?.filter(f => f.endsWith('.prisma'));
+        const steps = await (0, db_status_1.runSetupChecks)(interpolatedChecks, envValues, projectDir, projectName, prismaFiles);
         const completedSteps = steps.filter(s => s.done).map(s => s.label);
         const nextSteps = steps.filter(s => !s.done).map(s => s.hint ? `${s.label}: ${s.hint}` : s.label);
         if (nextSteps.length === 0) {

package/dist/commands/update.js

@@ -40,6 +40,7 @@ const child_process_1 = require("child_process");
 const project_1 = require("../lib/project");
 const capability_1 = require("../lib/capability");
 const update_1 = require("../lib/update");
+const scaffold_1 = require("../lib/scaffold");
 function runUpdate(capabilityName, options) {
     const targetDir = process.cwd();
     // Must be in a boop project
@@ -108,7 +109,8 @@ function runUpdate(capabilityName, options) {
                 const icon = action.action === 'overwrite' ? '\x1b[32m↑\x1b[0m'
                     : action.action === 'skip' ? '\x1b[33m◐\x1b[0m'
                         : action.action === 'add' ? '\x1b[32m+\x1b[0m'
-                            : '\x1b[90m⚠\x1b[0m';
+                            : action.action === 'migrate' ? '\x1b[36m↗\x1b[0m'
+                                : '\x1b[90m⚠\x1b[0m';
                 console.log(`  ${icon} ${action.relativePath} — ${action.reason}`);
             }
         }
@@ -127,6 +129,7 @@ function runUpdate(capabilityName, options) {
                 forcedOverwrite: [],
                 skippedDeleted: [],
                 pruned: [],
+                migrated: [],
                 unchangedCount: plan.unchangedCount,
             });
             continue;
@@ -134,6 +137,10 @@ function runUpdate(capabilityName, options) {
         const result = (0, update_1.executeUpdatePlan)(plan, { force: options.force, restore: options.restore, prune: options.prune });
         results.push(result);
     }
+    // Refresh .claude/skills/ symlinks for any new skill folders added by this update
+    if (!options.dryRun) {
+        (0, scaffold_1.linkSkillsToClaude)(targetDir);
+    }
     // Output
     if (options.json) {
         console.log(JSON.stringify({ capabilities: results }, null, 2));
@@ -144,6 +151,9 @@ function runUpdate(capabilityName, options) {
         const summary = (0, update_1.formatUpdateSummary)(result);
         console.log(`${result.capability}: ${summary}`);
         // Show details for non-trivial updates
+        for (const f of result.migrated || []) {
+            console.log(`  \x1b[36m↗\x1b[0m ${f} (migrated to folder)`);
+        }
         for (const f of result.overwritten) {
             if (result.forcedOverwrite.includes(f)) {
                 console.log(`  \x1b[33m⚠\x1b[0m ${f} (force-overwritten, backup saved)`);

package/dist/lib/db-status.d.ts

@@ -26,6 +26,16 @@ export declare function checkMigrationsTable(dbUrl: string): Promise<boolean | n
  * Returns true if prisma/migrations/ contains at least one migration subdirectory.
  */
 export declare function hasPrismaMigrations(projectDir: string): boolean;
+/**
+ * Parse a .prisma file and extract table names from model declarations.
+ * Returns the @@map() value if present, otherwise the model name.
+ */
+export declare function parsePrismaTableNames(filePath: string): string[];
+/**
+ * Check if specific tables exist in the database.
+ * Returns true if ALL tables exist, false if any are missing, null if psql unavailable.
+ */
+export declare function checkTablesExist(dbUrl: string, tableNames: string[]): Promise<boolean | null>;
 /**
  * Check if any .prisma files in the project define models.
  * Returns true if at least one file contains a `model` declaration.
@@ -52,6 +62,8 @@ export interface CheckContext {
     projectName: string;
     /** Accumulated results from earlier checks — keyed by check type. */
     results: Map<string, boolean>;
+    /** Capability's .prisma file paths relative to projectDir — enables scoped prisma-migrate checks. */
+    prismaFiles?: string[];
 }
 /**
  * Run all setup checks declared in a capability's setupChecks list.
@@ -61,4 +73,4 @@ export declare function runSetupChecks(checks: {
     type: string;
     label: string;
     hint?: string;
-}[], envValues: Map<string, string>, projectDir: string, projectName: string): Promise<SetupStep[]>;
+}[], envValues: Map<string, string>, projectDir: string, projectName: string, prismaFiles?: string[]): Promise<SetupStep[]>;

package/dist/lib/db-status.js

@@ -38,6 +38,8 @@ exports.checkTcpReachable = checkTcpReachable;
 exports.checkDatabaseConnectable = checkDatabaseConnectable;
 exports.checkMigrationsTable = checkMigrationsTable;
 exports.hasPrismaMigrations = hasPrismaMigrations;
+exports.parsePrismaTableNames = parsePrismaTableNames;
+exports.checkTablesExist = checkTablesExist;
 exports.hasPrismaModels = hasPrismaModels;
 exports.isPrismaClientGenerated = isPrismaClientGenerated;
 exports.checkPrismaMigrateStatus = checkPrismaMigrateStatus;
@@ -140,6 +142,77 @@ function hasPrismaMigrations(projectDir) {
     const entries = fs.readdirSync(migrationsDir, { withFileTypes: true });
     return entries.some(e => e.isDirectory());
 }
+/**
+ * Parse a .prisma file and extract table names from model declarations.
+ * Returns the @@map() value if present, otherwise the model name.
+ */
+function parsePrismaTableNames(filePath) {
+    if (!fs.existsSync(filePath))
+        return [];
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const tables = [];
+    const lines = content.split('\n');
+    let currentModel = null;
+    let braceDepth = 0;
+    let mapName = null;
+    for (const line of lines) {
+        const modelMatch = line.match(/^\s*model\s+(\w+)\s*\{/);
+        if (modelMatch && !currentModel) {
+            currentModel = modelMatch[1];
+            braceDepth = 1;
+            mapName = null;
+            continue;
+        }
+        if (currentModel) {
+            for (const ch of line) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            const mapMatch = line.match(/@@map\s*\(\s*"([^"]+)"\s*\)/);
+            if (mapMatch) {
+                mapName = mapMatch[1];
+            }
+            if (braceDepth === 0) {
+                tables.push(mapName || currentModel);
+                currentModel = null;
+                mapName = null;
+            }
+        }
+    }
+    return tables;
+}
+/**
+ * Check if specific tables exist in the database.
+ * Returns true if ALL tables exist, false if any are missing, null if psql unavailable.
+ */
+function checkTablesExist(dbUrl, tableNames) {
+    if (tableNames.length === 0)
+        return Promise.resolve(true);
+    // Validate table names — only allow alphanumeric and underscores
+    if (!tableNames.every(t => /^[a-zA-Z_]\w*$/.test(t))) {
+        return Promise.resolve(false);
+    }
+    const quotedNames = tableNames.map(t => `'${t}'`).join(',');
+    const query = `SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'public' AND table_name IN (${quotedNames})`;
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)('psql', [dbUrl, '-tAc', query], { timeout: 3000 }, (error, stdout) => {
+            if (error) {
+                if ('code' in error && error.code === 'ENOENT') {
+                    resolve(null);
+                }
+                else {
+                    resolve(false);
+                }
+            }
+            else {
+                const count = parseInt(stdout.trim(), 10);
+                resolve(count === tableNames.length);
+            }
+        });
+    });
+}
 /**
  * Check if any .prisma files in the project define models.
  * Returns true if at least one file contains a `model` declaration.
@@ -216,7 +289,28 @@ async function runCheck(type, ctx) {
             // Skip only if a database check was explicitly run and failed
             if (ctx.results.has('database') && !ctx.results.get('database'))
                 return false;
-            // If schema has models but no migrations exist, migration hasn't been run
+            // Scoped check: when prismaFiles are provided, check this capability's tables instead of global status
+            if (ctx.prismaFiles?.length) {
+                const tableNames = [];
+                for (const file of ctx.prismaFiles) {
+                    const filePath = path.join(ctx.projectDir, file);
+                    tableNames.push(...parsePrismaTableNames(filePath));
+                }
+                if (tableNames.length > 0) {
+                    // Capability defines models — check if its tables exist in the DB
+                    const dbUrl = ctx.envValues.get('DATABASE_URL');
+                    if (!dbUrl)
+                        return false;
+                    return (await checkTablesExist(dbUrl, tableNames)) === true;
+                }
+                // Capability has prisma files but no models (e.g., base schema) —
+                // check if _prisma_migrations table exists (initial migration was run)
+                const dbUrl = ctx.envValues.get('DATABASE_URL');
+                if (!dbUrl)
+                    return false;
+                return (await checkMigrationsTable(dbUrl)) === true;
+            }
+            // Fallback: no capability context — use global check
             if (hasPrismaModels(ctx.projectDir) && !hasPrismaMigrations(ctx.projectDir))
                 return false;
             const result = await checkPrismaMigrateStatus(ctx.projectDir);
@@ -233,8 +327,8 @@ async function runCheck(type, ctx) {
  * Run all setup checks declared in a capability's setupChecks list.
  * Returns an ordered list of steps with live done/pending status.
  */
-async function runSetupChecks(checks, envValues, projectDir, projectName) {
-    const ctx = { envValues, projectDir, projectName, results: new Map() };
+async function runSetupChecks(checks, envValues, projectDir, projectName, prismaFiles) {
+    const ctx = { envValues, projectDir, projectName, results: new Map(), prismaFiles };
     const steps = [];
     for (const check of checks) {
         const done = await runCheck(check.type, ctx);

package/dist/lib/execute.js

@@ -100,6 +100,7 @@ function executeTask(task, manifest) {
     switch (task.op) {
         case 'copy-files': {
             (0, scaffold_1.copyCapabilityFiles)(targetDir, capabilityName);
+            (0, scaffold_1.linkSkillsToClaude)(targetDir);
             break;
         }
         case 'merge-deps': {
@@ -154,10 +155,6 @@ function executeTask(task, manifest) {
             (0, scaffold_1.injectCssImports)(targetDir, data.cssCapMap, { skipBackup: true });
             break;
         }
-        case 'generate-skills-index': {
-            (0, scaffold_1.generateSkillsIndex)(targetDir);
-            break;
-        }
         case 'update-manifest': {
             const data = task.data;
             const projectManifest = (0, project_1.readProjectManifest)(targetDir);

package/dist/lib/manifest.d.ts

@@ -7,7 +7,7 @@
  * Phase 2 (execute) walks the manifest, performing each operation and
  * updating task status.
  */
-export type ManifestOp = 'copy-files' | 'merge-deps' | 'merge-scripts' | 'link-package' | 'inject-hook' | 'inject-css' | 'set-env' | 'generate-skills-index' | 'update-manifest' | 'run-command';
+export type ManifestOp = 'copy-files' | 'merge-deps' | 'merge-scripts' | 'link-package' | 'inject-hook' | 'inject-css' | 'set-env' | 'update-manifest' | 'run-command';
 export type TaskStatus = 'pending' | 'done' | 'failed' | 'skipped';
 export interface ManifestTask {
     op: ManifestOp;

package/dist/lib/preflight.js

@@ -329,14 +329,6 @@ function planAdd(targetDir, capabilityName) {
             data: { cssCapMap },
         });
     }
-    // Task: regenerate skills index
-    tasks.push({
-        op: 'generate-skills-index',
-        source: capabilityName,
-        target: path.join(targetDir, 'skills', 'index.md'),
-        detail: 'Regenerate skills/index.md',
-        status: 'pending',
-    });
     // Task: update manifest
     tasks.push({
         op: 'update-manifest',

package/dist/lib/scaffold.d.ts

@@ -36,6 +36,18 @@ export declare function hashFile(filePath: string): string;
  * Returns list of copied file paths relative to targetDir, and file hashes.
  */
 export declare function copyCapabilityFiles(targetDir: string, capabilityName: string, searchPaths?: string[]): string[];
+/**
+ * Symlink each skill folder under `<targetDir>/skills/` into
+ * `<targetDir>/.claude/skills/` so Claude Code's built-in Skill tool
+ * auto-discovers them alongside any plugin-installed skills.
+ *
+ * Per-folder symlinks (rather than a single dir-level symlink) so existing
+ * `.claude/skills/<other>` entries (Claude Code plugins, user-authored skills)
+ * are preserved.
+ *
+ * Idempotent. Returns the relative paths of symlinks created or already present.
+ */
+export declare function linkSkillsToClaude(targetDir: string): string[];
 /**
  * Merge dependencies into an existing package.json.
  * Does not overwrite existing dependency versions.
@@ -83,9 +95,4 @@ interface CapabilityHookEntry {
  * prevent arbitrary code injection into scaffolded projects.
  */
 export declare function collectHooks(capabilities: CapabilityHookEntry[]): HookVariables;
-/**
- * Generate skills/index.md from the .skill.md files present in the project.
- * Overwrites any existing index.md.
- */
-export declare function generateSkillsIndex(targetDir: string): void;
 export {};

package/dist/lib/scaffold.js

@@ -40,11 +40,11 @@ exports.renderTemplate = renderTemplate;
 exports.scaffoldKernel = scaffoldKernel;
 exports.hashFile = hashFile;
 exports.copyCapabilityFiles = copyCapabilityFiles;
+exports.linkSkillsToClaude = linkSkillsToClaude;
 exports.getBoopkitVersion = getBoopkitVersion;
 exports.mergePackageJson = mergePackageJson;
 exports.injectCssImports = injectCssImports;
 exports.collectHooks = collectHooks;
-exports.generateSkillsIndex = generateSkillsIndex;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
@@ -139,6 +139,19 @@ function copyCapabilityFiles(targetDir, capabilityName, searchPaths) {
     // Fallback to source tree
     return copyFromSourceTree(targetDir, capabilityName);
 }
+function walkDir(dir) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkDir(fullPath));
+        }
+        else {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
 /**
  * Copy capability files from a package directory.
  */
@@ -153,10 +166,14 @@ function copyFromPackage(targetDir, capabilityName, pkgDir, boopkit) {
             (0, safe_io_1.safeCopyDir)(skillsDir, destSkillsDir, { onConflict: 'skip' });
             const entries = fs.readdirSync(skillsDir);
             for (const entry of entries) {
-                const destPath = path.join(destSkillsDir, entry);
-                copied.push(path.join('skills', entry));
-                if (fs.existsSync(destPath)) {
-                    fileHashes[path.join('skills', entry)] = hashFile(destPath);
+                const srcEntryPath = path.join(skillsDir, entry);
+                if (fs.statSync(srcEntryPath).isDirectory()) {
+                    const files = walkDir(path.join(destSkillsDir, entry));
+                    for (const filePath of files) {
+                        const rel = path.join('skills', entry, path.relative(path.join(destSkillsDir, entry), filePath));
+                        copied.push(rel);
+                        fileHashes[rel] = hashFile(filePath);
+                    }
                 }
             }
         }
@@ -182,6 +199,42 @@ function copyFromPackage(targetDir, capabilityName, pkgDir, boopkit) {
     }
     return copied;
 }
+/**
+ * Symlink each skill folder under `<targetDir>/skills/` into
+ * `<targetDir>/.claude/skills/` so Claude Code's built-in Skill tool
+ * auto-discovers them alongside any plugin-installed skills.
+ *
+ * Per-folder symlinks (rather than a single dir-level symlink) so existing
+ * `.claude/skills/<other>` entries (Claude Code plugins, user-authored skills)
+ * are preserved.
+ *
+ * Idempotent. Returns the relative paths of symlinks created or already present.
+ */
+function linkSkillsToClaude(targetDir) {
+    const skillsDir = path.join(targetDir, 'skills');
+    if (!fs.existsSync(skillsDir))
+        return [];
+    const claudeSkillsDir = path.join(targetDir, '.claude', 'skills');
+    fs.mkdirSync(claudeSkillsDir, { recursive: true });
+    const linked = [];
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const linkPath = path.join(claudeSkillsDir, entry.name);
+        const target = path.join('..', '..', 'skills', entry.name);
+        const rel = path.join('.claude', 'skills', entry.name);
+        const existing = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+        if (existing) {
+            if (existing.isSymbolicLink() && fs.readlinkSync(linkPath) === target) {
+                linked.push(rel);
+            }
+            continue;
+        }
+        fs.symlinkSync(target, linkPath);
+        linked.push(rel);
+    }
+    return linked;
+}
 /**
  * Copy capability files from the capabilities/ source tree (test fixtures only).
  */
@@ -198,7 +251,13 @@ function copyFromSourceTree(targetDir, capabilityName) {
         (0, safe_io_1.safeCopyDir)(skillsDir, destSkillsDir, { onConflict: 'skip' });
         const entries = fs.readdirSync(skillsDir);
         for (const entry of entries) {
-            copied.push(path.join('skills', entry));
+            const srcEntryPath = path.join(skillsDir, entry);
+            if (fs.statSync(srcEntryPath).isDirectory()) {
+                const files = walkDir(path.join(destSkillsDir, entry));
+                for (const filePath of files) {
+                    copied.push(path.join('skills', entry, path.relative(path.join(destSkillsDir, entry), filePath)));
+                }
+            }
         }
     }
     // Scaffold files declared in the capability manifest
@@ -481,97 +540,3 @@ function collectHooks(capabilities) {
         hookPostRoutes: renderPhase('postRoutes'),
     };
 }
-/**
- * Preamble for generated skills/index.md.
- * Edit here to change the header text in every generated project.
- */
-const SKILLS_INDEX_PREAMBLE = [
-    '# About Skills',
-    '## Writing new skills',
-    'When writing a new skill, create a markdown file in this directory using the pattern `<topic>.skill.md`.',
-    'Each skill is a concise set of concrete steps that an AI agent can take to achieve a specific goal or perform a specific task.',
-    'Preface the skill with "When you ... " to help the agent understand when to use it.',
-    '',
-    '## Current skills',
-];
-/**
- * Category display names for skill file prefixes.
- * Unknown prefixes get title-cased automatically.
- */
-const SKILL_CATEGORIES = {
-    code: 'Code',
-    design: 'Design',
-    product: 'Product',
-    proj: 'Project',
-    reqs: 'Requirements and Docs',
-    skills: 'Skills',
-    test: 'Testing',
-    web: 'Web',
-    world: 'World',
-};
-/**
- * Extract the H1 title and first content line from a skill markdown file.
- */
-function parseSkillFile(content) {
-    const lines = content.split('\n');
-    let title = '';
-    let description = '';
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!title && trimmed.startsWith('# ')) {
-            title = trimmed.slice(2).trim();
-            continue;
-        }
-        if (title && !description && trimmed.length > 0 && !trimmed.startsWith('#')) {
-            description = trimmed;
-            break;
-        }
-    }
-    return { title: title || 'Untitled', description };
-}
-/**
- * Generate skills/index.md from the .skill.md files present in the project.
- * Overwrites any existing index.md.
- */
-function generateSkillsIndex(targetDir) {
-    const skillsDir = path.join(targetDir, 'skills');
-    if (!fs.existsSync(skillsDir))
-        return;
-    const files = fs.readdirSync(skillsDir)
-        .filter(f => f.endsWith('.skill.md'))
-        .sort();
-    if (files.length === 0)
-        return;
-    const entries = [];
-    for (const filename of files) {
-        const content = fs.readFileSync(path.join(skillsDir, filename), 'utf-8');
-        const { title, description } = parseSkillFile(content);
-        const category = filename.split('.')[0];
-        entries.push({ filename, title, description, category });
-    }
-    // Group by category
-    const grouped = new Map();
-    for (const entry of entries) {
-        const list = grouped.get(entry.category) || [];
-        list.push(entry);
-        grouped.set(entry.category, list);
-    }
-    // Sort categories by display name
-    const sortedCategories = [...grouped.keys()].sort((a, b) => {
-        const nameA = SKILL_CATEGORIES[a] || a;
-        const nameB = SKILL_CATEGORIES[b] || b;
-        return nameA.localeCompare(nameB);
-    });
-    const lines = [...SKILLS_INDEX_PREAMBLE];
-    for (const category of sortedCategories) {
-        const displayName = SKILL_CATEGORIES[category]
-            || category.charAt(0).toUpperCase() + category.slice(1);
-        lines.push(`### ${displayName}`);
-        for (const skill of grouped.get(category)) {
-            const desc = skill.description ? ` - ${skill.description}` : '';
-            lines.push(`- [**${skill.title}**](${skill.filename})${desc}`);
-        }
-        lines.push('');
-    }
-    fs.writeFileSync(path.join(skillsDir, 'index.md'), lines.join('\n'), 'utf-8');
-}

package/dist/lib/update.d.ts

@@ -10,7 +10,7 @@ export interface FileUpdateAction {
     /** Relative path from project root */
     relativePath: string;
     /** What will happen to this file */
-    action: 'overwrite' | 'skip' | 'add' | 'deprecate';
+    action: 'overwrite' | 'skip' | 'add' | 'deprecate' | 'migrate';
     /** Why this action was chosen */
     reason: string;
     /** Stored hash from config */
@@ -19,6 +19,8 @@ export interface FileUpdateAction {
     currentHash?: string;
     /** New hash from package */
     newHash?: string;
+    /** For migrate actions: the old file path being replaced */
+    oldPath?: string;
 }
 export interface UpdatePlan {
     capability: string;
@@ -46,6 +48,8 @@ export interface UpdateResult {
     skippedDeleted: string[];
     /** Files removed from disk via --prune */
     pruned: string[];
+    /** Files migrated from old flat format to new folder format */
+    migrated: string[];
     /** Count of files unchanged in both package and locally */
     unchangedCount: number;
 }

package/dist/lib/update.js

@@ -92,15 +92,19 @@ function planCapabilityUpdate(targetDir, capabilityName, projectManifest) {
             collectFiles(scaffoldDir, scaffoldDir, packageFiles);
         }
     }
-    // Collect files from package skills dir
+    // Collect files from package skills dir (both flat files and folder-based skills)
     if (boopkit.skillsDir) {
         const skillsDir = path.join(pkgDir, boopkit.skillsDir);
         if (fs.existsSync(skillsDir)) {
             const entries = fs.readdirSync(skillsDir);
             for (const entry of entries) {
                 const srcPath = path.join(skillsDir, entry);
-                if (fs.statSync(srcPath).isFile()) {
-                    packageFiles.set(path.join('skills', entry), srcPath);
+                if (fs.statSync(srcPath).isDirectory()) {
+                    const subFiles = new Map();
+                    collectFiles(srcPath, srcPath, subFiles);
+                    for (const [subRel, subAbs] of subFiles) {
+                        packageFiles.set(path.join('skills', entry, subRel), subAbs);
+                    }
                 }
             }
         }
@@ -184,6 +188,53 @@ function planCapabilityUpdate(targetDir, capabilityName, projectManifest) {
             });
         }
     }
+    // Apply skill migration logic: upgrade deprecate+add pairs to migrate actions
+    const capJsonPath = path.join(pkgDir, 'capability.json');
+    if (fs.existsSync(capJsonPath)) {
+        const capJson = JSON.parse(fs.readFileSync(capJsonPath, 'utf-8'));
+        const migrations = capJson.skill_migrations;
+        if (migrations) {
+            for (const [newSkillName, oldFlatFilename] of Object.entries(migrations)) {
+                const oldRelPath = path.join('skills', oldFlatFilename);
+                const newPrefix = path.join('skills', newSkillName) + path.sep;
+                const oldStoredHash = storedHashes[oldRelPath];
+                if (!oldStoredHash)
+                    continue;
+                const oldFilePath = path.join(targetDir, oldRelPath);
+                const oldState = compareFileHash(oldFilePath, oldStoredHash);
+                if (oldState === 'modified') {
+                    // User modified the old file — skip new folder files, keep old file
+                    for (const action of actions) {
+                        if (action.relativePath.startsWith(newPrefix) || action.relativePath === path.join('skills', newSkillName)) {
+                            action.action = 'skip';
+                            action.reason = `Skipped: old skill file '${oldRelPath}' was locally modified`;
+                        }
+                    }
+                    // Change deprecate to skip for the old file
+                    const oldAction = actions.find(a => a.relativePath === oldRelPath);
+                    if (oldAction) {
+                        oldAction.action = 'skip';
+                        oldAction.reason = 'Locally modified (migration skipped)';
+                    }
+                }
+                else if (oldState === 'match') {
+                    // Old file unmodified — convert deprecate to migrate
+                    const oldAction = actions.find(a => a.relativePath === oldRelPath);
+                    if (oldAction) {
+                        oldAction.action = 'migrate';
+                        oldAction.reason = `Migrated to folder: skills/${newSkillName}/`;
+                    }
+                    // Tag new folder files with the old path they're replacing
+                    for (const action of actions) {
+                        if (action.relativePath.startsWith(newPrefix) || action.relativePath === path.join('skills', newSkillName)) {
+                            action.oldPath = oldRelPath;
+                        }
+                    }
+                }
+                // oldState === 'missing': old file already gone, add new files normally
+            }
+        }
+    }
     const upToDate = actions.length === 0;
     return {
         capability: capabilityName,
@@ -210,6 +261,7 @@ function executeUpdatePlan(plan, options = {}) {
         forcedOverwrite: [],
         skippedDeleted: [],
         pruned: [],
+        migrated: [],
         unchangedCount: plan.unchangedCount,
     };
     const pkgJson = JSON.parse(fs.readFileSync(path.join(plan.packageDir, 'package.json'), 'utf-8'));
@@ -294,6 +346,17 @@ function executeUpdatePlan(plan, options = {}) {
                 }
                 break;
             }
+            case 'migrate': {
+                const oldFilePath = path.join(plan.targetDir, action.relativePath);
+                if (fs.existsSync(oldFilePath)) {
+                    (0, safe_io_1.createBackup)(oldFilePath);
+                    fs.unlinkSync(oldFilePath);
+                }
+                delete newHashes[action.relativePath];
+                result.migrated.push(action.relativePath);
+                console.warn(`\x1b[33mWARN\x1b[0m Migrated skill: ${action.relativePath} → ${action.reason}`);
+                break;
+            }
         }
     }
     // Update .boop/config.json
@@ -314,10 +377,10 @@ function executeUpdatePlan(plan, options = {}) {
  * Resolve the source path for a relative file path from the package.
  */
 function resolveSourcePath(pkgDir, boopkit, relativePath) {
-    // Skills are stored as skills/<filename> in relPath
+    // Skills are stored as skills/<filename> or skills/<folder>/<file> in relPath
     if (relativePath.startsWith('skills/') && boopkit.skillsDir) {
-        const filename = relativePath.slice('skills/'.length);
-        const srcPath = path.join(pkgDir, boopkit.skillsDir, filename);
+        const subPath = relativePath.slice('skills/'.length);
+        const srcPath = path.join(pkgDir, boopkit.skillsDir, subPath);
         return fs.existsSync(srcPath) ? srcPath : null;
     }
     // Scaffold files
@@ -348,6 +411,9 @@ function collectFiles(baseDir, dir, result) {
  */
 function formatUpdateSummary(result) {
     const parts = [];
+    if (result.migrated && result.migrated.length > 0) {
+        parts.push(`migrated ${result.migrated.length} skill${result.migrated.length === 1 ? '' : 's'}`);
+    }
     const normalOverwrites = result.overwritten.length - result.forcedOverwrite.length;
     if (normalOverwrites > 0) {
         parts.push(`Updated ${normalOverwrites} file${normalOverwrites === 1 ? '' : 's'}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boopkit/cli",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "boop: the opinionated bootstrap for founder friendly, AI-first web apps - code plus agent skills, composable from day one.",
   "main": "dist/cli.js",
   "workspaces": [
@@ -20,8 +20,8 @@
   "scripts": {
     "build": "tsc && node tools/generate-version-manifest.js",
     "build:caps": "./tools/build-caps.sh",
-    "publish" : "./tools/publish-caps.sh",
-    "release" : "./tools/publish-caps.sh --release",
+    "publish": "./tools/publish-caps.sh",
+    "release": "./tools/publish-caps.sh --release",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",
     "test": "jest"

package/profiles/web-app/reference/message-queue-patterns.ref.md

@@ -24,7 +24,7 @@ await MessageQueueService.publish('batch-ready', [message1, message2]);
 - **Reuse**: The same connection and channel are reused for all subsequent publishes
 - **Auto-reconnect**: If the connection drops (`error` or `close` event), the cached reference is cleared and the next `publish()` call opens a fresh connection
 - **Error recovery**: If `publish()` catches an error (e.g., channel closed), it resets connection state and returns `false` — the next call will reconnect
-- **Shutdown**: The publish connection is tracked in `listenerConnections` and closed by the coordinated SIGINT handler alongside listener connections
+- **Shutdown**: The publish connection is tracked and closed by `close()` alongside the listener connection
 
 ### Why persistent (not per-call)
 
@@ -36,6 +36,21 @@ The original implementation opened a new AMQP connection for every `publish()` c
 |--------|-------|-----------|
 | Scheduler jobs | various | 1-2 per 10-min cycle |
 
+## Listening
+
+`MessageQueueService.listen()` uses a **shared AMQP connection** across all queue consumers. Each `listen()` call creates a separate **channel** on the shared connection. This keeps connection count at 2 (1 publish + 1 listen) regardless of how many queues are consumed.
+
+### Connection lifecycle
+
+- **Lazy init**: No connection is opened until the first `listen()` call
+- **Shared**: All listeners share the same connection; each gets its own channel with independent prefetch and consumer
+- **Auto-reconnect**: If the connection drops (`error` or `close` event), the cached reference is cleared and the next `listen()` call opens a fresh connection
+- **Shutdown**: The listener connection is closed by `close()` alongside the publish connection
+
+### Why shared (not per-queue)
+
+CloudAMQP's shared plan has a 20-connection limit. The previous implementation opened a new AMQP connection per `listen()` call. AMQP supports multiple channels on a single connection — each channel can have its own prefetch and consumer — so sharing one connection scales to any number of queue consumers without hitting connection limits.
+
 ## Consumer Modes
 
 The `MessageQueueService.listen()` function supports two modes controlled by `opts.manualAck`:

package/src/templates/kernel/AGENTS.md.hbs

@@ -9,8 +9,7 @@ Don't confirm a hypothesis (or take action) without observation - logs, tests, a
 
 ## How to work in this project
 
-0. **Read the skills index now.** Open [skills/index.md](skills/index.md) before doing anything else in this session. You need to know what skills exist before you can apply rule 1.
-1. **Check skills first.** Before coding, reviewing, testing, designing, debugging, filing issues, or proposing any non-trivial change, check [skills/index.md](skills/index.md) for a matching skill and follow its process. Do not rely on general knowledge when a project skill exists.
+1. **Prefer project skills over general knowledge.** When a skill matches your task — coding, reviewing, testing, designing, debugging, filing issues — follow its `SKILL.md` instead of working from memory. Skills live in `skills/` (each is a folder with a `SKILL.md`) and are also exposed at `.claude/skills/` for tooling that auto-discovers there. If your tooling does not auto-surface skills, list `skills/` and read each `SKILL.md`'s frontmatter (`name`, `description`) to find a match.
 2. **Use boop for capabilities.** Run `boop caps` to see what's available. To add features like database, auth, or other services and infrastructure, run `boop add <capability>` — don't install or wire things manually.
 3. **Check project status.** If the system isn't working or new capabilities need to be added run `boop status` to see what's configured and what needs attention.
 4. **Run `boop --help`** for the full command list.
@@ -21,7 +20,7 @@ Read [reference/boop-guide.ref.md](reference/boop-guide.ref.md) to understand ho
 
 ## Project layout
 - `src/` — source code
-- `skills/` — process skills for agents (read `skills/index.md`)
+- `skills/` — process skills for agents (each skill is a folder with a `SKILL.md`); also linked from `.claude/skills/` for Claude Code's built-in skill discovery
 - `reference/` — architecture and coding standards ("what exists now")
 - `specs/` — design docs and specifications ("future state")
 - `tests/` — `npm test` (Jest)