@boopkit/cli 0.8.0 → 0.8.2

package/dist/commands/loop.js

@@ -57,12 +57,14 @@ exports.buildPrompt = buildPrompt;
 exports.shouldRotateSession = shouldRotateSession;
 exports.sessionDidWork = sessionDidWork;
 exports.splitStreamLines = splitStreamLines;
+exports.sessionEnv = sessionEnv;
 exports.runLoop = runLoop;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
 const string_decoder_1 = require("string_decoder");
+const init_1 = require("./init");
 /**
  * Output cap for every `bd … --json` read the loop makes.
  *
@@ -131,13 +133,22 @@ function readReadyQueue(execSyncFn) {
 /**
  * Hard requirement: beads must run in Dolt server mode so concurrent worktrees
  * share one issue DB over TCP. Reads `.beads/metadata.json` and throws an
- * actionable error on embedded/missing — call before any `bd` work.
+ * actionable error on embedded/missing — call before any `bd` work. A project
+ * with no `.beads/` at all (one started with `boop add`) is told the `bd init`
+ * command `boop init` would have run. The messages name no skill file, because
+ * an installed project may not have the one boop's own repository does.
  */
 function assertDoltServerMode(projectDir, deps) {
     const existsSyncFn = deps?.existsSyncFn || fs.existsSync;
     const readFileFn = deps?.readFileFn || ((p, enc) => fs.readFileSync(p, enc));
-    const metaPath = path.join(projectDir, '.beads', 'metadata.json');
-    const fix = 'Migrate beads to Dolt server mode before running the loop; see skills/boop-dolt-recovery/SKILL.md';
+    const beadsDir = path.join(projectDir, '.beads');
+    const metaPath = path.join(beadsDir, 'metadata.json');
+    if (!existsSyncFn(beadsDir)) {
+        const initCommand = `bd ${(0, init_1.bdInitArgs)(path.basename(path.resolve(projectDir))).join(' ')}`;
+        throw new Error(`beads is not set up in ${projectDir}: there is no .beads folder. ` +
+            `The loop tracks its work in beads, running in Dolt server mode. To set it up, run this from the project folder:\n  ${initCommand}`);
+    }
+    const fix = 'Switch this project\'s beads to Dolt server mode before running the loop.';
     if (!existsSyncFn(metaPath)) {
         throw new Error(`beads metadata not found at ${metaPath}. The loop requires Dolt server mode for concurrent worktrees. ${fix}`);
     }
@@ -500,8 +511,10 @@ async function planWork(opts) {
     const prompt = buildPlanningPrompt(workContent, flowContent, opts.prefix);
     const sessionId = (0, crypto_1.randomUUID)();
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
-    const logFile = path.join(opts.logDir, `_planning_${opts.prefix}_${timestamp}.log`);
-    const readableLogFile = path.join(opts.logDir, `_planning_${opts.prefix}_${timestamp}.readable.log`);
+    // A spec-driven run usually has no prefix, so fall back to the spec's base name.
+    const runName = opts.prefix || path.basename(opts.workPath, path.extname(opts.workPath));
+    const logFile = path.join(opts.logDir, `_planning_${runName}_${timestamp}.log`);
+    const readableLogFile = path.join(opts.logDir, `_planning_${runName}_${timestamp}.readable.log`);
     // Write readable log header
     fs.writeFileSync(readableLogFile, `=== Planning Session ===\nSession: ${sessionId}\nStarted: ${new Date().toISOString()}\n\n`);
     console.log(`\x1b[32m[bd-loop]\x1b[0m 📋 Starting planning phase...`);
@@ -915,7 +928,7 @@ function readInstalledSkills(projectDir) {
 /**
  * The installed skills an issue description names, by bare name or by path, in
  * the order each is first mentioned. A name only matches whole, so
- * boop-testing-testing does not match inside boop-testing-testing-express-web.
+ * boop-testing-testing does not match inside boop-testing-testing-integration.
  */
 function namedSkills(description, installed) {
     const found = [];
@@ -1075,6 +1088,24 @@ function splitStreamLines(carry, chunk) {
     const rest = pieces.pop() ?? '';
     return { lines: pieces.filter(Boolean), rest };
 }
+// Propagate the chosen model beyond this session via the environment.
+// `--model` (in args) sets this session; ANTHROPIC_MODEL additionally
+// (a) reaches a nested `boop loop` — child processes inherit the env — so it
+// doesn't reset to the default, and (b) is honored by any sub-agent whose
+// definition opts into `model: inherit`. We deliberately do NOT set
+// CLAUDE_CODE_SUBAGENT_MODEL: sub-agents keep their own declared model, so a
+// deliberately-cheap agent (e.g. Explore on Haiku) stays cheap. The invoking
+// agent can still override a sub-agent's model per-invocation when it needs
+// to. See resolveModel().
+//
+// CLAUDE_CODE_ENTRYPOINT marks the session as machine-driven, so its transcript
+// is not mistaken for one the operator typed into. CLAUDE_CODE_DISABLE_AUTO_MEMORY
+// keeps the operator's auto-memory index, written for their interactive session,
+// out of a coding session (honoured by Claude Code 2.1.296).
+function sessionEnv(model, env = process.env) {
+    const machineDriven = { ...env, CLAUDE_CODE_ENTRYPOINT: 'boop-loop', CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' };
+    return model ? { ...machineDriven, ANTHROPIC_MODEL: model } : machineDriven;
+}
 function runClaude(prompt, opts, logFile, readableLogFile) {
     return new Promise((resolve) => {
         const args = [
@@ -1105,19 +1136,7 @@ function runClaude(prompt, opts, logFile, readableLogFile) {
         const readableStream = readableLogFile
             ? fs.createWriteStream(readableLogFile, { flags: 'a' })
             : null;
-        // Propagate the chosen model beyond this session via the environment.
-        // `--model` (in args) sets this session; ANTHROPIC_MODEL additionally
-        // (a) reaches a nested `boop loop` — child processes inherit the env — so it
-        // doesn't reset to the default, and (b) is honored by any sub-agent whose
-        // definition opts into `model: inherit`. We deliberately do NOT set
-        // CLAUDE_CODE_SUBAGENT_MODEL: sub-agents keep their own declared model, so a
-        // deliberately-cheap agent (e.g. Explore on Haiku) stays cheap. The invoking
-        // agent can still override a sub-agent's model per-invocation when it needs
-        // to. See resolveModel().
-        const childEnv = opts.model
-            ? { ...process.env, ANTHROPIC_MODEL: opts.model }
-            : process.env;
-        const child = (0, child_process_1.spawn)(claudeBin, args, { cwd: opts.cwd, stdio: ['pipe', 'pipe', 'pipe'], env: childEnv });
+        const child = (0, child_process_1.spawn)(claudeBin, args, { cwd: opts.cwd, stdio: ['pipe', 'pipe', 'pipe'], env: sessionEnv(opts.model) });
         let limitHit = false;
         // Track context-window pressure from outside the agent (spec: the loop reads
         // the stream it already parses; the agent is never told). Peak occupancy over

package/dist/commands/migrate-skill-edits.js

@@ -51,7 +51,7 @@ function runMigrateSkillEdits(deps = {}) {
     const projectDir = process.cwd();
     const manifest = (0, project_1.readProjectManifest)(projectDir);
     if (!manifest) {
-        console.error('\x1b[31mERR\x1b[0m Not a boop project (no .boop/config.json). Run `boop init` first.');
+        console.error('\x1b[31mERR\x1b[0m Not a boop project (no .boop/config.json). Run `boop init` in an empty folder, or `boop add <capability>` in an existing project, first.');
         process.exitCode = 1;
         return;
     }
@@ -67,7 +67,7 @@ async function runApplySkillEdits(deps = terminalDeps()) {
     const projectDir = process.cwd();
     const manifest = (0, project_1.readProjectManifest)(projectDir);
     if (!manifest) {
-        console.error('\x1b[31mERR\x1b[0m Not a boop project (no .boop/config.json). Run `boop init` first.');
+        console.error('\x1b[31mERR\x1b[0m Not a boop project (no .boop/config.json). Run `boop init` in an empty folder, or `boop add <capability>` in an existing project, first.');
         process.exitCode = 1;
         return;
     }

package/dist/commands/status.d.ts

@@ -1,4 +1,5 @@
 import { BoopManifest } from '../lib/project';
+import { MoveState } from '../lib/moves';
 export interface CapabilityStatusEnvVar {
     required?: string;
     set: boolean;
@@ -13,6 +14,15 @@ export interface CapabilityStatus {
     reachable?: boolean;
     /** Skills whose SKILL.md this project has edited, which no boop update can improve until the edits move out */
     skillEdits?: SkillEditsStatus;
+    /** Paths leaving this capability for another, which the move pass of `boop update` has not settled */
+    moves?: PendingMove[];
+}
+export interface PendingMove {
+    path: string;
+    toCapability: string;
+    toPath: string;
+    state: MoveState;
+    instruction: string;
 }
 export interface SkillEditsStatus {
     edited: number;

package/dist/commands/status.js

@@ -46,6 +46,7 @@ const capability_1 = require("../lib/capability");
 const interpolate_1 = require("../lib/interpolate");
 const db_status_1 = require("../lib/db-status");
 const update_1 = require("../lib/update");
+const moves_1 = require("../lib/moves");
 function formatStatus(manifest) {
     const caps = manifest.capabilities.length > 0
         ? manifest.capabilities.join(', ')
@@ -104,7 +105,7 @@ function getStatusData(manifest, dir) {
             const isSet = setKeys.has(varName) || hasLiteralDefault;
             envStatus[varName] = { required: decl.required, set: isSet };
             if (!isSet) {
-                const isRequired = decl.required && decl.required !== 'false';
+                const isRequired = decl.required === 'boot' || decl.required === 'runtime';
                 if (isRequired) {
                     allRequiredSet = false;
                     // Look for a setupCheck hint for this env var
@@ -164,6 +165,21 @@ function getStatusData(manifest, dir) {
             capabilities[capName].skillEdits = { ...counts, instruction: update_1.SKILL_EDITS_INSTRUCTION };
         }
     }
+    // Every move the move pass finds, listed under the capability the files are leaving
+    for (const move of (0, moves_1.planMoves)(dir, manifest, manifest.capabilities).moves) {
+        const entry = capabilities[move.fromCapability];
+        if (!entry)
+            continue;
+        const instruction = move.instruction
+            ?? (move.state === 'split-will-add' ? `\`boop update\` adds ${move.toCapability}.` : 'Run `boop update`.');
+        entry.moves = [...(entry.moves ?? []), {
+                path: move.from,
+                toCapability: move.toCapability,
+                toPath: move.to,
+                state: move.state,
+                instruction,
+            }];
+    }
     return { name: manifest.name, profile: manifest.profile, capabilities };
 }
 // Re-export for backward compatibility in tests
@@ -261,6 +277,15 @@ function formatCapabilityLine(capName, cap) {
         lines.push(`                    \x1b[33m◐\x1b[0m ${edited} skill${edited === 1 ? '' : 's'} edited in SKILL.md, ${changesWaiting} with boop changes waiting`);
         lines.push(`                    → ${instruction}`);
     }
+    for (const move of cap.moves ?? []) {
+        const from = move.path.replace(/\/$/, '');
+        const as = move.toPath.endsWith('/') ? ` as ${path.basename(move.toPath)}` : '';
+        const label = move.state === 'split-will-add'
+            ? `${move.toCapability} split from ${capName}: ${from} moves into it`
+            : `${from} moved to ${move.toCapability}${as}, waiting`;
+        lines.push(`                    \x1b[33m◐\x1b[0m ${label}`);
+        lines.push(`                    → ${move.instruction}`);
+    }
     return lines;
 }
 /**
@@ -301,7 +326,7 @@ async function runStatus(options) {
         throw err;
     }
     if (!manifest) {
-        console.error('Not a boop project (no .boop/config.json found). Run `boop init` to create one.');
+        console.error('Not a boop project (no .boop/config.json found). Run `boop init` in an empty folder, or `boop add <capability>` in an existing project, to create one.');
         process.exitCode = 1;
         return;
     }

package/dist/commands/update.js

@@ -40,14 +40,18 @@ 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 moves_1 = require("../lib/moves");
+const capability_2 = require("../lib/capability");
+const preflight_1 = require("../lib/preflight");
+const execute_1 = require("../lib/execute");
 const scaffold_1 = require("../lib/scaffold");
 const stale_scripts_1 = require("../lib/stale-scripts");
 function runUpdate(capabilityName, options) {
     const targetDir = process.cwd();
     // Must be in a boop project
-    const manifest = (0, project_1.readProjectManifest)(targetDir);
+    let manifest = (0, project_1.readProjectManifest)(targetDir);
     if (!manifest) {
-        console.error(`\x1b[31mERR\x1b[0m Not a boop project (no .boop/config.json). Run \`boop init\` first.`);
+        console.error(`\x1b[31mERR\x1b[0m Not a boop project (no .boop/config.json). Run \`boop init\` in an empty folder, or \`boop add <capability>\` in an existing project, first.`);
         process.exitCode = 1;
         return;
     }
@@ -76,10 +80,44 @@ function runUpdate(capabilityName, options) {
             }
         }
     }
-    // Plan all updates
+    // Step 2: the move pass, against the freshly installed packages. A path a
+    // capability stopped shipping because another ships it now is settled before
+    // either capability is planned (specs/skill-moves.spec.md).
+    let movePlan = (0, moves_1.planMoves)(targetDir, manifest, capsToUpdate);
+    const capabilitiesAdded = [];
+    let moveResults = new Map();
+    if (!options.dryRun) {
+        // Step 3: add each capability split out of an installed one, then settle the moves again with it installed
+        if (movePlan.splitsToAdd.length > 0) {
+            const unaddable = {};
+            for (const split of movePlan.splitsToAdd) {
+                const reason = addSplitCapability(targetDir, split.capability, (0, moves_1.arrivingPaths)(movePlan.moves, split.capability), options);
+                if (reason) {
+                    unaddable[split.capability] = reason;
+                }
+                else {
+                    capabilitiesAdded.push(split);
+                }
+            }
+            manifest = (0, project_1.readProjectManifest)(targetDir);
+            movePlan = (0, moves_1.planMoves)(targetDir, manifest, [...capsToUpdate, ...capabilitiesAdded.map(a => a.capability)], { unaddable });
+        }
+        // Step 4: renames, hash transfers and removals, with the manifest written once
+        moveResults = (0, moves_1.executeMoves)(targetDir, movePlan.moves);
+        manifest = (0, project_1.readProjectManifest)(targetDir);
+    }
+    // Step 5: plan each capability against the manifest the moves wrote. What a
+    // move did not carry out (a hold, a deprecation) belongs to the leaving
+    // capability's plan; in a dry run, every move does, and the receiving
+    // capability leaves the arriving paths to it.
     const plans = [];
-    for (const cap of capsToUpdate) {
-        const plan = (0, update_1.planCapabilityUpdate)(targetDir, cap, manifest);
+    for (const cap of [...capsToUpdate, ...capabilitiesAdded.map(a => a.capability)]) {
+        const pending = movePlan.moves.filter(m => m.fromCapability === cap
+            && (options.dryRun || m.outcome === 'hold' || m.outcome === 'deprecate'));
+        const plan = (0, update_1.planCapabilityUpdate)(targetDir, cap, manifest, {
+            moves: pending.flatMap(moves_1.moveActions),
+            arriving: options.dryRun ? (0, moves_1.arrivingPaths)(movePlan.moves, cap) : [],
+        });
         if (plan) {
             plans.push(plan);
         }
@@ -101,6 +139,9 @@ function runUpdate(capabilityName, options) {
             console.log(JSON.stringify({ capabilities: plans, staleScripts: stale }, null, 2));
             return;
         }
+        for (const split of movePlan.splitsToAdd) {
+            console.log(`\nwould add capability ${split.capability} (split from ${split.splitFrom})`);
+        }
         for (const plan of plans) {
             console.log(`\n${plan.capability}:`);
             // Recording a hash for a file that already holds what boop ships changes nothing the project can see
@@ -115,8 +156,9 @@ 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'
-                            : action.action === 'migrate' ? '\x1b[36m↗\x1b[0m'
-                                : '\x1b[90m⚠\x1b[0m';
+                            : action.action === 'migrate' || action.action === 'move' ? '\x1b[36m↗\x1b[0m'
+                                : action.action === 'remove' ? '\x1b[31m✕\x1b[0m'
+                                    : '\x1b[90m⚠\x1b[0m';
                 const label = action.action === 'skip' && (action.drift || action.instruction) ? skipLabel(action) : action.reason;
                 console.log(`  ${icon} ${action.relativePath} — ${label}`);
                 if (action.instruction)
@@ -136,28 +178,31 @@ function runUpdate(capabilityName, options) {
     for (const plan of plans) {
         if (plan.upToDate) {
             results.push({
-                capability: plan.capability,
-                overwritten: [],
-                skipped: [],
-                added: [],
-                deprecated: [],
-                forcedOverwrite: [],
-                skippedDeleted: [],
-                pruned: [],
-                migrated: [],
-                scriptsAdded: [],
+                ...emptyResult(plan.capability),
                 scriptsKept: plan.scriptActions.filter(a => a.action === 'keep'),
                 unchangedCount: plan.unchangedCount,
-                instructions: [],
             });
             continue;
         }
         const result = (0, update_1.executeUpdatePlan)(plan, { force: options.force, restore: options.restore, prune: options.prune });
         results.push(result);
     }
+    // Each executed move is reported under the capability the files left
+    for (const moveResult of moveResults.values()) {
+        let result = results.find(r => r.capability === moveResult.capability);
+        if (!result) {
+            result = emptyResult(moveResult.capability);
+            results.push(result);
+        }
+        result.moved.push(...moveResult.moved);
+        result.removed.push(...moveResult.removed);
+        result.instructions.push(...moveResult.instructions);
+    }
     // Refresh .claude/skills/ symlinks for any new skill folders added by this update,
-    // and put back any PROJECT.md the project has deleted
+    // put back any PROJECT.md the project has deleted, and bring each capability's
+    // stored env settings in line with what its package declares now
     if (!options.dryRun) {
+        (0, update_1.refreshCapabilityEnv)(targetDir, plans.map(p => p.capability));
         (0, scaffold_1.linkSkillsToClaude)(targetDir);
         (0, scaffold_1.createSkillProjectFiles)(targetDir);
     }
@@ -173,17 +218,25 @@ function runUpdate(capabilityName, options) {
     if (options.json) {
         console.log(JSON.stringify({
             capabilities: results,
+            capabilitiesAdded,
             staleScripts: remainingStale,
             fixedScripts,
         }, null, 2));
         return;
     }
     console.log(`\n${'─'.repeat(40)}`);
-    results.forEach((result, i) => {
+    for (const added of capabilitiesAdded) {
+        console.log(`added capability ${added.capability} (split from ${added.splitFrom})`);
+    }
+    results.forEach((result) => {
         const summary = (0, update_1.formatUpdateSummary)(result);
         console.log(`${result.capability}: ${summary}`);
-        const actionFor = (f) => plans[i].actions.find(a => a.relativePath === f);
+        const plan = plans.find(p => p.capability === result.capability);
+        const actionFor = (f) => plan?.actions.find(a => a.relativePath === f);
         const instructionFor = (f) => result.instructions.find(entry => entry.relativePath === f)?.instruction;
+        for (const line of moveLines(result, movePlan)) {
+            console.log(line);
+        }
         // Show details for non-trivial updates
         for (const f of result.migrated || []) {
             console.log(`  \x1b[36m↗\x1b[0m ${f} (migrated to folder)`);
@@ -217,9 +270,13 @@ function runUpdate(capabilityName, options) {
             console.log(`  \x1b[32m+\x1b[0m ${f} (new)`);
         }
         for (const f of result.deprecated) {
+            const movedTo = actionFor(f)?.toCapability;
             if (result.pruned?.includes(f)) {
                 console.log(`  \x1b[31m✕\x1b[0m ${f} (pruned, backup saved)`);
             }
+            else if (movedTo) {
+                console.log(`  \x1b[33m⚠\x1b[0m ${f} (deprecated — now ships in ${movedTo}, which this project does not install; use --prune to delete)`);
+            }
             else {
                 console.log(`  \x1b[33m⚠\x1b[0m ${f} (deprecated — removed from package, use --prune to delete)`);
             }
@@ -235,6 +292,81 @@ function runUpdate(capabilityName, options) {
         console.log(`\n${(0, stale_scripts_1.formatStaleScriptWarning)(remainingStale)}`);
     }
 }
+/**
+ * The report's lines for the moves the update carried out from one capability:
+ * each folder or file moved, with where it went, and each skill folder removed
+ * because the capability that ships it now is not installed here.
+ */
+function moveLines(result, movePlan) {
+    const lines = [];
+    const instructionFor = (f) => result.instructions.find(entry => entry.relativePath === f)?.instruction;
+    for (const moved of result.moved) {
+        const planned = movePlan.moves.find(m => m.fromCapability === result.capability && m.from === moved.from);
+        const carried = planned?.projectFileCarried ? '; PROJECT.md carried across' : '';
+        lines.push(`  \x1b[36m↗\x1b[0m ${moved.from} → ${moved.to} (${moved.toCapability}${carried})`);
+        const instruction = instructionFor(moved.from);
+        if (instruction)
+            lines.push(instructionLine(instruction));
+    }
+    for (const removed of result.removed) {
+        const planned = movePlan.moves.find(m => m.fromCapability === result.capability && m.from === removed);
+        const toCapability = planned?.toCapability;
+        const name = path.basename(planned?.to ?? removed);
+        lines.push(`  \x1b[31m✕\x1b[0m ${removed} (removed: now ships in ${toCapability} as ${name}, which this project does not install; \`boop add ${toCapability}\` brings it back)`);
+    }
+    return lines;
+}
+/**
+ * Install a capability split out of an installed one, and add it as `boop add`
+ * would, except that the paths arriving by move are not copied: the move
+ * decides what happens to them. Returns why it could not be added, or null.
+ */
+function addSplitCapability(targetDir, capability, arriving, options) {
+    if (!(0, capability_1.getPackageDir)(capability, [targetDir])) {
+        if (options.skipNpm) {
+            return `its package is not installed, and --skip-npm kept boop from installing it`;
+        }
+        const packageName = (0, capability_2.getCatalogEntry)(capability)?.package ?? `@boopkit/cap-${capability}`;
+        const spec = options.tag ? `${packageName}@${options.tag}` : packageName;
+        try {
+            (0, child_process_1.execSync)(`npm install ${spec}`, { cwd: targetDir, stdio: options.json ? 'pipe' : 'inherit' });
+        }
+        catch {
+            return `npm install ${spec} failed`;
+        }
+    }
+    try {
+        const { manifest } = (0, preflight_1.planAdd)(targetDir, capability, { excludePaths: arriving });
+        (0, execute_1.executeManifest)(manifest, { install: !options.skipNpm });
+        return null;
+    }
+    catch (err) {
+        if (err instanceof preflight_1.PreflightError) {
+            return err.checks.filter(c => !c.passed).map(c => c.message).join('; ');
+        }
+        throw err;
+    }
+}
+function emptyResult(capability) {
+    return {
+        capability,
+        overwritten: [],
+        skipped: [],
+        added: [],
+        deprecated: [],
+        forcedOverwrite: [],
+        skippedDeleted: [],
+        pruned: [],
+        migrated: [],
+        scriptsAdded: [],
+        scriptsKept: [],
+        unchangedCount: 0,
+        instructions: [],
+        moved: [],
+        removed: [],
+        movesWaiting: [],
+    };
+}
 /**
  * How the report shows the npm scripts a capability declares: an added one reads
  * like a new file, and a kept one shows the command the capability ships, so a
@@ -265,6 +397,10 @@ function isEditDoingItsJob(action) {
 }
 /** What the report says happened to a file the update skipped */
 function skipLabel(action) {
+    if (action?.movedTo) {
+        const as = action.movedTo.endsWith('/') ? ` as ${path.basename(action.movedTo)}` : '';
+        return `moved to ${action.toCapability}${as}, waiting`;
+    }
     if (action?.drift === 'project-only')
         return 'edited here, skipped';
     if (action?.drift === 'both-changed') {

package/dist/lib/capability.js

@@ -105,8 +105,11 @@ function getCapabilityFromPackage(name, searchPaths) {
     const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
     if (!pkgJson.boopkit?.capability)
         return null;
+    // A capability ships as the package it sits in, so its package.json name is
+    // the package when capability.json does not say. Five skill capabilities
+    // never said, and `boop add` then never made them a project dependency.
     const capJson = JSON.parse(fs.readFileSync(capJsonPath, 'utf-8'));
-    return capJson;
+    return { ...capJson, package: capJson.package ?? pkgJson.name };
 }
 /**
  * Scan node_modules/@boopkit/cap-* to find a package whose capability.json

package/dist/lib/execute.js

@@ -62,7 +62,7 @@ function executeManifest(manifest, options = {}) {
     // Back up each mutable target file once before executing any tasks
     const backedUp = new Set();
     for (const task of manifest.tasks) {
-        if (task.op === 'copy-files' || task.op === 'run-command')
+        if (task.op === 'copy-files' || task.op === 'run-command' || task.op === 'install-package')
             continue;
         if (task.target && fs.existsSync(task.target) && !backedUp.has(task.target)) {
             (0, safe_io_1.createBackup)(task.target);
@@ -99,8 +99,25 @@ function executeManifest(manifest, options = {}) {
 function executeTask(task, manifest) {
     const { targetDir, capability: capabilityName } = manifest;
     switch (task.op) {
+        case 'create-package-json': {
+            const data = task.data;
+            fs.writeFileSync(task.target, (0, scaffold_1.renderBasePackageJson)(data.projectName), 'utf-8');
+            break;
+        }
+        case 'create-manifest': {
+            const data = task.data;
+            (0, project_1.writeProjectManifest)(targetDir, data.manifest);
+            break;
+        }
+        case 'install-package': {
+            const data = task.data;
+            console.error(`Running ${data.command}...`);
+            (0, child_process_1.execSync)(data.command, { cwd: targetDir, stdio: 'pipe' });
+            break;
+        }
         case 'copy-files': {
-            (0, scaffold_1.copyCapabilityFiles)(targetDir, capabilityName);
+            const data = task.data;
+            (0, scaffold_1.copyCapabilityFiles)(targetDir, capabilityName, undefined, data.exclude);
             (0, scaffold_1.linkSkillsToClaude)(targetDir);
             (0, scaffold_1.createSkillProjectFiles)(targetDir);
             break;
@@ -169,7 +186,17 @@ function executeTask(task, manifest) {
         case 'run-command': {
             const data = task.data;
             console.log(`\nRunning ${data.command}...`);
-            (0, child_process_1.execSync)(data.command, { cwd: targetDir, stdio: 'inherit' });
+            // stderr is captured rather than inherited so that a failure's warning
+            // carries the command's own error text; on success it is passed through.
+            const result = (0, child_process_1.spawnSync)(data.command, { cwd: targetDir, shell: true, stdio: ['inherit', 'inherit', 'pipe'] });
+            if (result.error)
+                throw result.error;
+            const stderr = result.stderr.toString();
+            if (result.status !== 0) {
+                const exit = result.signal ? `signal ${result.signal}` : `exit code ${result.status}`;
+                throw new Error(`Command failed (${exit}): ${data.command}\n${stderr}`);
+            }
+            process.stderr.write(stderr);
             break;
         }
     }

package/dist/lib/install-layout.d.ts

@@ -52,6 +52,11 @@ export declare function describePlacementOwner(placement: Placement): string;
  * has no need of npm module resolution (and must not require a build).
  */
 export declare function capabilityPlacementsFromDir(pkgDir: string): Placement[];
+/**
+ * Whether a project-relative path is one of `paths`, or lies inside one that
+ * names a folder (ends in `/`).
+ */
+export declare function isUnderAny(relPath: string, paths: string[]): boolean;
 /**
  * Every file a capability ships and where it lands in a project.
  *

package/dist/lib/install-layout.js

@@ -53,6 +53,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlacementCollisionError = void 0;
 exports.describePlacementOwner = describePlacementOwner;
 exports.capabilityPlacementsFromDir = capabilityPlacementsFromDir;
+exports.isUnderAny = isUnderAny;
 exports.capabilityPlacements = capabilityPlacements;
 exports.profilePlacements = profilePlacements;
 exports.skillDirectoryPlacements = skillDirectoryPlacements;
@@ -160,6 +161,13 @@ function capabilityPlacementsFromDir(pkgDir) {
     }
     return placements;
 }
+/**
+ * Whether a project-relative path is one of `paths`, or lies inside one that
+ * names a folder (ends in `/`).
+ */
+function isUnderAny(relPath, paths) {
+    return paths.some(p => p.endsWith('/') ? relPath.startsWith(p) : relPath === p);
+}
 function isCapabilityPackage(pkgDir) {
     const pkgJsonPath = path.join(pkgDir, 'package.json');
     if (!fs.existsSync(pkgJsonPath))

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' | 'update-manifest' | 'run-command';
+export type ManifestOp = 'create-package-json' | 'create-manifest' | 'install-package' | '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;