@boopkit/cli 0.6.14 → 0.6.15

package/dist/capability-versions.json

@@ -2,21 +2,21 @@
   "@boopkit/cap-api": "0.4.5",
   "@boopkit/cap-background-jobs": "0.4.3",
   "@boopkit/cap-cloud-storage": "0.4.1",
-  "@boopkit/cap-coding": "0.4.5",
+  "@boopkit/cap-coding": "0.4.6",
   "@boopkit/cap-database": "0.4.4",
   "@boopkit/cap-email": "0.4.3",
   "@boopkit/cap-hello": "0.4.1",
   "@boopkit/cap-noticeboard": "0.4.1",
   "@boopkit/cap-oauth-client": "0.1.1",
   "@boopkit/cap-oauth-server": "0.1.4",
-  "@boopkit/cap-product-design": "0.6.8",
-  "@boopkit/cap-project-mgmt": "0.4.10",
+  "@boopkit/cap-product-design": "0.6.9",
+  "@boopkit/cap-project-mgmt": "0.4.11",
   "@boopkit/cap-services": "0.4.3",
-  "@boopkit/cap-skills": "0.5.5",
+  "@boopkit/cap-skills": "0.5.6",
   "@boopkit/cap-testing": "0.5.7",
   "@boopkit/cap-users": "0.8.1",
   "@boopkit/cap-ux": "0.2.3",
   "@boopkit/cap-web": "0.5.5",
-  "@boopkit/cap-workflows": "0.2.1",
+  "@boopkit/cap-workflows": "0.2.2",
   "@boopkit/logger": "0.4.0"
 }

package/dist/commands/init.js

@@ -369,7 +369,7 @@ function runInit(name, options, deps = {}) {
     (0, scaffold_1.injectCssImports)(targetDir, cssCapMap, { skipBackup: true });
     // --- Symlink skills/* into .claude/skills/ for Claude Code auto-discovery, and give each a PROJECT.md ---
     (0, scaffold_1.linkSkillsToClaude)(targetDir);
-    (0, scaffold_1.createSkillProjectFiles)(targetDir);
+    (0, scaffold_1.createSkillProjectFiles)(targetDir, capSearchPaths);
     // --- Merge capability scripts into package.json ---
     if (Object.keys(allScripts).length > 0) {
         const pkgPath = path.join(targetDir, 'package.json');

package/dist/commands/update.js

@@ -105,7 +105,7 @@ function runUpdate(capabilityName, options) {
             console.log(`\n${plan.capability}:`);
             // Recording a hash for a file that already holds what boop ships changes nothing the project can see
             const visible = plan.actions.filter(a => a.action !== 'record-hash');
-            if (visible.length === 0) {
+            if (visible.length === 0 && plan.scriptActions.length === 0) {
                 console.log('  Already up to date');
                 continue;
             }
@@ -122,6 +122,9 @@ function runUpdate(capabilityName, options) {
                 if (action.instruction)
                     console.log(instructionLine(action.instruction));
             }
+            for (const line of scriptLines(plan.scriptActions)) {
+                console.log(line);
+            }
         }
         if (stale.length > 0) {
             console.log(`\n${(0, stale_scripts_1.formatStaleScriptWarning)(stale)}`);
@@ -142,6 +145,8 @@ function runUpdate(capabilityName, options) {
                 skippedDeleted: [],
                 pruned: [],
                 migrated: [],
+                scriptsAdded: [],
+                scriptsKept: plan.scriptActions.filter(a => a.action === 'keep'),
                 unchangedCount: plan.unchangedCount,
                 instructions: [],
             });
@@ -219,6 +224,9 @@ function runUpdate(capabilityName, options) {
                 console.log(`  \x1b[33m⚠\x1b[0m ${f} (deprecated — removed from package, use --prune to delete)`);
             }
         }
+        for (const line of scriptLines([...(result.scriptsAdded || []), ...(result.scriptsKept || [])])) {
+            console.log(line);
+        }
     });
     for (const fixed of fixedScripts) {
         console.log(`\n\x1b[32m✓\x1b[0m package.json script "${fixed.name}" rewritten: ${fixed.command} → ${fixed.rewritten}`);
@@ -227,6 +235,27 @@ function runUpdate(capabilityName, options) {
         console.log(`\n${(0, stale_scripts_1.formatStaleScriptWarning)(remainingStale)}`);
     }
 }
+/**
+ * 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
+ * project whose own command has fallen behind can see that it has. The label
+ * claims only that the commands differ: with no record of the command boop wrote,
+ * a command an older capability version shipped looks just like a customisation.
+ */
+function scriptLines(actions) {
+    const lines = [];
+    for (const action of actions) {
+        if (action.action === 'add') {
+            lines.push(`  \x1b[32m+\x1b[0m npm run ${action.name} (new script)`);
+            lines.push(instructionLine(action.command));
+        }
+        else {
+            lines.push(`  \x1b[33m◐\x1b[0m npm run ${action.name} (your command differs; kept)`);
+            lines.push(instructionLine(`this capability ships: ${action.command}`));
+        }
+    }
+    return lines;
+}
 /**
  * A reference page or code file the project edited, and boop has not, is doing
  * what those files are for, so the report does not list it.

package/dist/lib/execute.js

@@ -50,6 +50,7 @@ const project_1 = require("./project");
 const env_1 = require("./env");
 const rewire_1 = require("./rewire");
 const safe_io_1 = require("./safe-io");
+const script_merge_1 = require("./script-merge");
 /**
  * Execute all tasks in a manifest. Returns the result with per-task status.
  */
@@ -110,19 +111,9 @@ function executeTask(task, manifest) {
             break;
         }
         case 'merge-scripts': {
+            // One answer to "does this script go in", shared with `boop update`
             const data = task.data;
-            const pkgPath = path.join(targetDir, 'package.json');
-            if (fs.existsSync(pkgPath)) {
-                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-                if (!pkg.scripts)
-                    pkg.scripts = {};
-                for (const [scriptName, scriptDef] of Object.entries(data.scripts)) {
-                    if (!(scriptName in pkg.scripts)) {
-                        pkg.scripts[scriptName] = scriptDef.cmd;
-                    }
-                }
-                fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
-            }
+            (0, script_merge_1.applyScriptUpdates)(targetDir, (0, script_merge_1.planScriptUpdates)(data.scripts, (0, script_merge_1.readProjectScripts)(targetDir)));
             break;
         }
         case 'link-package': {

package/dist/lib/scaffold.d.ts

@@ -70,17 +70,47 @@ export declare function copyCapabilityFiles(targetDir: string, capabilityName: s
  */
 export declare function linkSkillsToClaude(targetDir: string, only?: Iterable<string>): string[];
 /**
- * Give every skill folder under `<targetDir>/skills/` that lacks one a
- * `PROJECT.md`, where the project records how it applies the skill. Each boop
- * `SKILL.md` opens by pointing at it; the file being present is the backstop
- * for an agent that skipped the pointer.
+ * The names of the skill folders under `<targetDir>/skills/` that boop installed.
+ *
+ * A project's `skills/` is not all boop's: a project writes skills of its own
+ * beside the ones its capabilities ship, and those folders are already entirely
+ * the project's file. Two records say which are boop's, and the union is taken
+ * because neither is complete on its own:
+ *
+ * - the `fileHashes` a capability stored in `.boop/config.json`, which is the
+ *   record of what was actually copied into this project;
+ * - the skill placements of an installed capability that has no stored hashes —
+ *   a manifest written before `capabilityMeta` existed, or one whose hash
+ *   storage was skipped.
+ *
+ * Returns null when the directory holds no `.boop/config.json`, i.e. nothing
+ * here is a boop project and no folder can be attributed either way.
+ */
+export declare function installedSkillNames(targetDir: string, searchPaths?: string[]): Set<string> | null;
+/**
+ * Give every boop-installed skill folder under `<targetDir>/skills/` that lacks
+ * one a `PROJECT.md`, where the project records how it applies the skill. Each
+ * boop `SKILL.md` opens by pointing at it; the file being present is the
+ * backstop for an agent that skipped the pointer.
+ *
+ * Only a folder boop installed gets one. A skill the project wrote itself is
+ * already the project's file outright, so a `PROJECT.md` beside it separates
+ * nothing — and because this runs on every init, add and update, a project
+ * could never delete the stub it left there.
+ *
+ * For the same reason it takes back a stub an earlier boop wrote beside a
+ * project-owned skill, but only while the file's bytes are still exactly the
+ * template's: anything the project typed into a `PROJECT.md` keeps it.
  *
  * The file is the project's: boop never hashes it, so `boop update` can never
  * report it, and an existing one is never opened for writing.
  *
- * Returns the relative paths of the files created.
+ * Returns the relative paths of the files created and of the stubs removed.
  */
-export declare function createSkillProjectFiles(targetDir: string): string[];
+export declare function createSkillProjectFiles(targetDir: string, searchPaths?: string[]): {
+    created: string[];
+    removed: string[];
+};
 /**
  * Whether a skill's PROJECT.md has rules under "Offered to boop" — anything in
  * that section beyond the template's own explanation of it.

package/dist/lib/scaffold.js

@@ -44,6 +44,7 @@ exports.hashFile = hashFile;
 exports.hashContent = hashContent;
 exports.copyCapabilityFiles = copyCapabilityFiles;
 exports.linkSkillsToClaude = linkSkillsToClaude;
+exports.installedSkillNames = installedSkillNames;
 exports.createSkillProjectFiles = createSkillProjectFiles;
 exports.hasOfferedRules = hasOfferedRules;
 exports.readSkillProjectTemplate = readSkillProjectTemplate;
@@ -60,6 +61,7 @@ const config_1 = require("./config");
 const capability_1 = require("./capability");
 const safe_io_1 = require("./safe-io");
 const install_layout_1 = require("./install-layout");
+const project_1 = require("./project");
 /**
  * Render a single Handlebars template string with variables.
  *
@@ -254,34 +256,101 @@ function linkSkillsToClaude(targetDir, only) {
     return linked;
 }
 /**
- * Give every skill folder under `<targetDir>/skills/` that lacks one a
- * `PROJECT.md`, where the project records how it applies the skill. Each boop
- * `SKILL.md` opens by pointing at it; the file being present is the backstop
- * for an agent that skipped the pointer.
+ * The names of the skill folders under `<targetDir>/skills/` that boop installed.
+ *
+ * A project's `skills/` is not all boop's: a project writes skills of its own
+ * beside the ones its capabilities ship, and those folders are already entirely
+ * the project's file. Two records say which are boop's, and the union is taken
+ * because neither is complete on its own:
+ *
+ * - the `fileHashes` a capability stored in `.boop/config.json`, which is the
+ *   record of what was actually copied into this project;
+ * - the skill placements of an installed capability that has no stored hashes —
+ *   a manifest written before `capabilityMeta` existed, or one whose hash
+ *   storage was skipped.
+ *
+ * Returns null when the directory holds no `.boop/config.json`, i.e. nothing
+ * here is a boop project and no folder can be attributed either way.
+ */
+function installedSkillNames(targetDir, searchPaths) {
+    const manifest = (0, project_1.readProjectManifest)(targetDir);
+    if (!manifest)
+        return null;
+    const names = new Set();
+    const addDest = (dest) => {
+        // Stored destinations are POSIX, but tolerate a manifest written on Windows.
+        const [top, skillName] = dest.split(/[\\/]/);
+        if (top === 'skills' && skillName)
+            names.add(skillName);
+    };
+    const meta = manifest.capabilityMeta ?? {};
+    for (const entry of Object.values(meta)) {
+        for (const dest of Object.keys(entry?.fileHashes ?? {}))
+            addDest(dest);
+    }
+    // Walking a package's files is the expensive half, so it runs only for a
+    // capability whose hashes are missing — where it is the only record left.
+    for (const capability of manifest.capabilities ?? []) {
+        if (Object.keys(meta[capability]?.fileHashes ?? {}).length > 0)
+            continue;
+        for (const placement of (0, install_layout_1.capabilityPlacements)(capability, searchPaths ?? [targetDir])) {
+            if (placement.kind === 'skill')
+                addDest(placement.dest);
+        }
+    }
+    return names;
+}
+/**
+ * Give every boop-installed skill folder under `<targetDir>/skills/` that lacks
+ * one a `PROJECT.md`, where the project records how it applies the skill. Each
+ * boop `SKILL.md` opens by pointing at it; the file being present is the
+ * backstop for an agent that skipped the pointer.
+ *
+ * Only a folder boop installed gets one. A skill the project wrote itself is
+ * already the project's file outright, so a `PROJECT.md` beside it separates
+ * nothing — and because this runs on every init, add and update, a project
+ * could never delete the stub it left there.
+ *
+ * For the same reason it takes back a stub an earlier boop wrote beside a
+ * project-owned skill, but only while the file's bytes are still exactly the
+ * template's: anything the project typed into a `PROJECT.md` keeps it.
  *
  * The file is the project's: boop never hashes it, so `boop update` can never
  * report it, and an existing one is never opened for writing.
  *
- * Returns the relative paths of the files created.
+ * Returns the relative paths of the files created and of the stubs removed.
  */
-function createSkillProjectFiles(targetDir) {
+function createSkillProjectFiles(targetDir, searchPaths) {
     const skillsDir = path.join(targetDir, 'skills');
     if (!fs.existsSync(skillsDir))
-        return [];
+        return { created: [], removed: [] };
+    const installed = installedSkillNames(targetDir, searchPaths);
+    if (installed === null)
+        return { created: [], removed: [] };
     const template = readSkillProjectTemplate();
     const created = [];
+    const removed = [];
     for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
         // A symlinked skill folder is someone else's. In the boop repository each one
         // points into a capability package, from which a PROJECT.md would ship to every project.
         if (!entry.isDirectory())
             continue;
         const filePath = path.join(skillsDir, entry.name, 'PROJECT.md');
-        if (fs.lstatSync(filePath, { throwIfNoEntry: false }))
+        const relPath = path.join('skills', entry.name, 'PROJECT.md');
+        const existing = fs.lstatSync(filePath, { throwIfNoEntry: false });
+        if (!installed.has(entry.name)) {
+            if (existing?.isFile() && fs.readFileSync(filePath, 'utf-8') === template) {
+                fs.unlinkSync(filePath);
+                removed.push(relPath);
+            }
+            continue;
+        }
+        if (existing)
             continue;
         fs.writeFileSync(filePath, template, { flag: 'wx' });
-        created.push(path.join('skills', entry.name, 'PROJECT.md'));
+        created.push(relPath);
     }
-    return created;
+    return { created, removed };
 }
 /**
  * Whether a skill's PROJECT.md has rules under "Offered to boop" — anything in

package/dist/lib/script-merge.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Merge the npm scripts a capability declares into a project's package.json
+ * during `boop update`.
+ *
+ * The case this exists for (boop-ldou): a capability ships a new command as two
+ * things — a file under `scaffold/`, and a `scripts` entry in `capability.json`.
+ * `boop add` merges those scripts at install time (see `merge-scripts` in
+ * lib/execute.ts), but `boop update` only ever copied files, so an upgraded
+ * project received `src/scripts/migrate-credentials.ts` and no way to run it by
+ * name. Every document, post-install note and status hint that said
+ * `npm run credentials:migrate` was right for a freshly scaffolded project and
+ * wrong for every upgraded one — precisely the projects a migration tool is for.
+ *
+ * The merge is additive, like `boop add`'s: a script is written only when the
+ * project has no script of that name. A name the project already uses is left
+ * exactly as it stands, because a command somebody customised is theirs, and
+ * clobbering it would be worse than leaving it alone — the same restraint
+ * `rewriteStaleRunnerScripts` shows when a command has changed underneath it.
+ * What boop does do is say so, so a kept command that no longer matches what the
+ * capability ships is visible rather than silent.
+ */
+import { CapabilityScript } from './config';
+export interface ScriptUpdateAction {
+    /** The script's key in package.json, e.g. `credentials:migrate`. */
+    name: string;
+    /** The command the capability declares. */
+    command: string;
+    /** `add` writes it; `keep` leaves the project's own command in place. */
+    action: 'add' | 'keep';
+    /** Why this action was chosen. */
+    reason: string;
+    /** The command the project has today, when there is one. */
+    currentCommand?: string;
+}
+/**
+ * Pure: given what a capability declares and what the project's package.json
+ * holds, decide what happens to each script.
+ *
+ * A script whose command already matches what the capability ships is not
+ * returned at all — there is nothing to do and nothing worth reporting.
+ */
+export declare function planScriptUpdates(declared: Record<string, CapabilityScript> | undefined, projectScripts: Record<string, string> | undefined): ScriptUpdateAction[];
+/**
+ * Write the `add` actions into the project's package.json, and return the ones
+ * actually written.
+ *
+ * Re-reads the file rather than trusting the plan: an action is applied only
+ * while the name is still free, so a script written between planning and here
+ * survives. A missing or unreadable package.json is not an error — scaffold
+ * files have already been delivered by the time this runs, and failing the whole
+ * update over the script merge would be worse than reporting nothing.
+ */
+export declare function applyScriptUpdates(targetDir: string, actions: ScriptUpdateAction[]): ScriptUpdateAction[];
+/** The project's package.json scripts, or undefined when there is no readable one. */
+export declare function readProjectScripts(targetDir: string): Record<string, string> | undefined;

package/dist/lib/script-merge.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Merge the npm scripts a capability declares into a project's package.json
+ * during `boop update`.
+ *
+ * The case this exists for (boop-ldou): a capability ships a new command as two
+ * things — a file under `scaffold/`, and a `scripts` entry in `capability.json`.
+ * `boop add` merges those scripts at install time (see `merge-scripts` in
+ * lib/execute.ts), but `boop update` only ever copied files, so an upgraded
+ * project received `src/scripts/migrate-credentials.ts` and no way to run it by
+ * name. Every document, post-install note and status hint that said
+ * `npm run credentials:migrate` was right for a freshly scaffolded project and
+ * wrong for every upgraded one — precisely the projects a migration tool is for.
+ *
+ * The merge is additive, like `boop add`'s: a script is written only when the
+ * project has no script of that name. A name the project already uses is left
+ * exactly as it stands, because a command somebody customised is theirs, and
+ * clobbering it would be worse than leaving it alone — the same restraint
+ * `rewriteStaleRunnerScripts` shows when a command has changed underneath it.
+ * What boop does do is say so, so a kept command that no longer matches what the
+ * capability ships is visible rather than silent.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planScriptUpdates = planScriptUpdates;
+exports.applyScriptUpdates = applyScriptUpdates;
+exports.readProjectScripts = readProjectScripts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Pure: given what a capability declares and what the project's package.json
+ * holds, decide what happens to each script.
+ *
+ * A script whose command already matches what the capability ships is not
+ * returned at all — there is nothing to do and nothing worth reporting.
+ */
+function planScriptUpdates(declared, projectScripts) {
+    if (!declared)
+        return [];
+    const actions = [];
+    for (const [name, script] of Object.entries(declared)) {
+        const command = typeof script === 'string' ? script : script?.cmd;
+        if (!command)
+            continue;
+        const currentCommand = projectScripts?.[name];
+        if (currentCommand === undefined) {
+            actions.push({ name, command, action: 'add', reason: 'New script from capability' });
+            continue;
+        }
+        if (currentCommand === command)
+            continue;
+        actions.push({
+            name,
+            command,
+            action: 'keep',
+            reason: 'Project has its own command for this script',
+            currentCommand,
+        });
+    }
+    return actions;
+}
+/**
+ * Write the `add` actions into the project's package.json, and return the ones
+ * actually written.
+ *
+ * Re-reads the file rather than trusting the plan: an action is applied only
+ * while the name is still free, so a script written between planning and here
+ * survives. A missing or unreadable package.json is not an error — scaffold
+ * files have already been delivered by the time this runs, and failing the whole
+ * update over the script merge would be worse than reporting nothing.
+ */
+function applyScriptUpdates(targetDir, actions) {
+    const additions = actions.filter(a => a.action === 'add');
+    if (additions.length === 0)
+        return [];
+    const pkgPath = path.join(targetDir, 'package.json');
+    if (!fs.existsSync(pkgPath))
+        return [];
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    if (!pkg.scripts)
+        pkg.scripts = {};
+    const applied = [];
+    for (const action of additions) {
+        if (action.name in pkg.scripts)
+            continue;
+        pkg.scripts[action.name] = action.command;
+        applied.push(action);
+    }
+    if (applied.length > 0) {
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+    }
+    return applied;
+}
+/** The project's package.json scripts, or undefined when there is no readable one. */
+function readProjectScripts(targetDir) {
+    const pkgPath = path.join(targetDir, 'package.json');
+    if (!fs.existsSync(pkgPath))
+        return undefined;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg.scripts;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/stale-scripts.d.ts

@@ -8,8 +8,9 @@
  * Jest never recycles, and a long suite dies as that process's heap grows.
  *
  * `boop update` cannot simply fix those projects. Scripts are merged only when
- * absent (see `merge-scripts` in lib/execute.ts), which is the right default —
- * clobbering a script somebody customised would be worse than leaving it stale.
+ * absent (see lib/script-merge.ts, which both `boop add` and `boop update` use),
+ * which is the right default — clobbering a script somebody customised would be
+ * worse than leaving it stale.
  * So the old command survives the update, and because a CLI `--runInBand` is the
  * first and unconditional branch of Jest's `shouldRunInBand()`, it overrides the
  * new config entirely. That is the state worth warning about: the project now has

package/dist/lib/stale-scripts.js

@@ -9,8 +9,9 @@
  * Jest never recycles, and a long suite dies as that process's heap grows.
  *
  * `boop update` cannot simply fix those projects. Scripts are merged only when
- * absent (see `merge-scripts` in lib/execute.ts), which is the right default —
- * clobbering a script somebody customised would be worse than leaving it stale.
+ * absent (see lib/script-merge.ts, which both `boop add` and `boop update` use),
+ * which is the right default — clobbering a script somebody customised would be
+ * worse than leaving it stale.
  * So the old command survives the update, and because a CLI `--runInBand` is the
  * first and unconditional branch of Jest's `shouldRunInBand()`, it overrides the
  * new config entirely. That is the state worth warning about: the project now has

package/dist/lib/update.d.ts

@@ -5,6 +5,7 @@
  * local modifications, then selectively updates from the capability package.
  */
 import { BoopManifest } from './project';
+import { ScriptUpdateAction } from './script-merge';
 export type FileState = 'match' | 'modified' | 'missing';
 /**
  * How a locally modified file stands against the base (what boop shipped last)
@@ -53,6 +54,8 @@ export interface UpdatePlan {
     newVersion: string;
     /** Per-file actions */
     actions: FileUpdateAction[];
+    /** What happens to each npm script the capability declares */
+    scriptActions: ScriptUpdateAction[];
     /** Number of files unchanged in both package and locally */
     unchangedCount: number;
     /** True if already up to date */
@@ -71,6 +74,10 @@ export interface UpdateResult {
     pruned: string[];
     /** Files migrated from old flat format to new folder format */
     migrated: string[];
+    /** npm scripts the capability declares that this update wrote into package.json */
+    scriptsAdded: ScriptUpdateAction[];
+    /** npm scripts left as the project has them, because it has its own command */
+    scriptsKept: ScriptUpdateAction[];
     /** Count of files unchanged in both package and locally */
     unchangedCount: number;
     /** What to do about the files this update skipped or replaced, where the report says anything */