start-vibing-stacks 2.23.0 → 2.25.0

package/README.md

@@ -6,7 +6,7 @@ Multi-stack AI workflow for **Claude Code** & **Cursor**. One command installs a
 npx start-vibing-stacks
 ```
 
-> Latest: **v2.23.0** — multi-instance coordination layer. Two or more Claude Code sessions in the same folder auto-discover each other through `.claude/state/`, share file-edit awareness, and refuse to overwrite each other's uncommitted work. New `/peers` slash command + `peers list/notify/locks/cleanup` CLI.
+> Latest: **v2.25.0** — `--force-hooks` (alias `--force-legacy`) now also covers legacy commands (`commands/*.md` without `version:` frontmatter), not just hooks. Single command rebuilds installs older than v2.23.0. v2.24.0 → smart migrate (versioned hooks/commands, idempotent `settings.json`, runtime dirs, `.gitignore`). v2.23.0 → multi-instance coordination layer.
 
 ---
 
@@ -130,13 +130,24 @@ Single-host coordination only. It does **not** replace `git` for cross-machine c
 ## CLI
 
 ```bash
-npx start-vibing-stacks                  # setup or resume current project
-npx start-vibing-stacks migrate          # show outdated/missing skills
-npx start-vibing-stacks migrate --apply  # update outdated skills/agents
+npx start-vibing-stacks                                # setup or resume current project
+npx start-vibing-stacks migrate                        # dry run: skills + agents + hooks + commands + settings.json + runtime dirs
+npx start-vibing-stacks migrate --apply                # apply (idempotent; preserves customizations)
+npx start-vibing-stacks migrate --apply --force-legacy # also overwrite legacy hooks AND commands (no version) — creates .bak
+npx start-vibing-stacks migrate --apply --force-hooks  # alias for --force-legacy (back-compat)
 
 # flags: --force --no-claude --no-mcp --no-install --help --version
 ```
 
+`migrate` is the safe upgrade path between releases. Each release gets:
+- **Hooks** versioned via `// @sv-version: x.y.z` header — semver-compared against installed.
+- **Commands** versioned via frontmatter `version:` — same as skills/agents.
+- **`settings.json#hooks`** — idempotent deep-merge: missing event blocks (`SessionStart`, `PreToolUse`, `PostToolUse`, `SessionEnd`) are appended; existing entries (including yours) are preserved.
+- **Runtime artefacts** — `.claude/state/{sessions,inbox,file-touches}/_archive` auto-created; `_state.README.md` staged.
+- **`.gitignore`** — `.claude/state/` appended if not already covered.
+
+Legacy files without versioning — hooks without `// @sv-version` AND commands without `version:` frontmatter (anything installed before the versioning landed) — are reported as `needs-update-legacy` and skipped by default. Pass `--force-legacy` (or its alias `--force-hooks`) to overwrite them — each gets a timestamped `.bak`. Skills and agents are intentionally **not** covered because users customize them; they stay in `modified-no-version` (advisory only).
+
 Global install: `npm i -g start-vibing-stacks` → `svs` (alias).
 
 ---

package/dist/index.js

@@ -33,6 +33,7 @@ const FLAGS = {
     help: args.includes('--help') || args.includes('-h'),
     version: args.includes('--version') || args.includes('-v'),
     apply: args.includes('--apply'),
+    forceHooks: args.includes('--force-hooks') || args.includes('--force-legacy'),
 };
 if (FLAGS.version) {
     console.log(PKG_VERSION);
@@ -52,6 +53,9 @@ if (FLAGS.help) {
   ${chalk.bold('Options:')}
     --force           Overwrite existing configuration (default command)
     --apply           Apply updates (migrate command)
+    --force-legacy    Overwrite legacy hooks (no @sv-version) AND legacy commands
+                      (no version: frontmatter) — each gets a timestamped .bak
+    --force-hooks     Alias for --force-legacy (kept for back-compat)
     --no-claude       Skip Claude Code installation
     --no-mcp          Skip MCP server selection
     --no-install      Skip dependency installation
@@ -68,7 +72,7 @@ if (FLAGS.help) {
 // Subcommand: migrate
 if (SUBCOMMAND === 'migrate') {
     const { runMigrate } = await import('./migrate.js');
-    await runMigrate(process.cwd(), { apply: FLAGS.apply });
+    await runMigrate(process.cwd(), { apply: FLAGS.apply, forceHooks: FLAGS.forceHooks });
     process.exit(0);
 }
 const AVAILABLE_STACKS = [

package/dist/migrate.d.ts

@@ -1,27 +1,49 @@
 /**
- * Start Vibing Stacks — Migrate
+ * Start Vibing Stacks — Migrate (v2 — smart, idempotent, settings-aware)
  *
- * Compares the SKILL.md / agent / hook versions installed in .claude/
- * against the bundled stacks/<stack>/ and stacks/_shared/ versions.
+ * Compares installed vs bundled versions for skills, agents, hooks AND commands.
+ * Also reconciles runtime artefacts that earlier migrate versions ignored:
  *
- * Reports outdated, missing, and modified items. Optionally upgrades.
- *
- * Skill version contract:
- *   YAML frontmatter at top of SKILL.md must include `version: X.Y.Z`.
- *   No frontmatter = treated as "v0" / pre-versioning.
+ *  - hooks: parsed via `// @sv-version: x.y.z` header. Legacy installs (no tag)
+ *    are skipped with a "needs-update-legacy" warning unless `--force-hooks` is
+ *    passed (which makes a `.bak` copy before overwriting).
+ *  - commands: same `version:` frontmatter contract as skills/agents.
+ *  - .claude/settings.json — patched idempotently to ensure the bundled hook
+ *    chain (SessionStart / UserPromptSubmit / PreToolUse / PostToolUse / Stop /
+ *    SessionEnd) is wired. Existing entries are preserved; only missing entries
+ *    are appended. Atomic write (.tmp + rename).
+ *  - .claude/state/ — runtime layout for multi-instance coordination is
+ *    auto-created and the `_state.README.md` is staged as `.claude/state/README.md`.
+ *  - .gitignore — `.claude/state/` is appended if not already covered.
  */
+type Status = 'missing' | 'outdated' | 'current' | 'ahead' | 'modified-no-version' | 'needs-update-legacy';
 export interface MigrateItem {
-    kind: 'skill' | 'agent' | 'hook';
+    kind: 'skill' | 'agent' | 'hook' | 'command';
     name: string;
     source: string;
     target: string;
     bundledVersion: string;
     installedVersion: string | null;
-    status: 'missing' | 'outdated' | 'current' | 'ahead' | 'modified-no-version';
+    status: Status;
 }
 export interface MigrateOptions {
     apply: boolean;
-    scope?: 'skills' | 'agents' | 'hooks' | 'all';
+    scope?: 'skills' | 'agents' | 'hooks' | 'commands' | 'all';
+    forceHooks?: boolean;
 }
 export declare function planMigration(projectDir: string, opts: MigrateOptions): MigrateItem[];
+interface SettingsPatchReport {
+    added: string[];
+    alreadyPresent: string[];
+    fileExisted: boolean;
+    error?: string;
+}
+export declare function patchSettings(projectDir: string, dryRun: boolean): SettingsPatchReport;
+interface RuntimeReport {
+    created: string[];
+    copied: string[];
+    gitignoreUpdated: boolean;
+}
+export declare function ensureRuntimeArtefacts(projectDir: string, dryRun: boolean): RuntimeReport;
 export declare function runMigrate(projectDir: string, opts: MigrateOptions): Promise<void>;
+export {};

package/dist/migrate.js

@@ -1,18 +1,25 @@
 /**
- * Start Vibing Stacks — Migrate
+ * Start Vibing Stacks — Migrate (v2 — smart, idempotent, settings-aware)
  *
- * Compares the SKILL.md / agent / hook versions installed in .claude/
- * against the bundled stacks/<stack>/ and stacks/_shared/ versions.
+ * Compares installed vs bundled versions for skills, agents, hooks AND commands.
+ * Also reconciles runtime artefacts that earlier migrate versions ignored:
  *
- * Reports outdated, missing, and modified items. Optionally upgrades.
- *
- * Skill version contract:
- *   YAML frontmatter at top of SKILL.md must include `version: X.Y.Z`.
- *   No frontmatter = treated as "v0" / pre-versioning.
+ *  - hooks: parsed via `// @sv-version: x.y.z` header. Legacy installs (no tag)
+ *    are skipped with a "needs-update-legacy" warning unless `--force-hooks` is
+ *    passed (which makes a `.bak` copy before overwriting).
+ *  - commands: same `version:` frontmatter contract as skills/agents.
+ *  - .claude/settings.json — patched idempotently to ensure the bundled hook
+ *    chain (SessionStart / UserPromptSubmit / PreToolUse / PostToolUse / Stop /
+ *    SessionEnd) is wired. Existing entries are preserved; only missing entries
+ *    are appended. Atomic write (.tmp + rename).
+ *  - .claude/state/ — runtime layout for multi-instance coordination is
+ *    auto-created and the `_state.README.md` is staged as `.claude/state/README.md`.
+ *  - .gitignore — `.claude/state/` is appended if not already covered.
  */
-import { existsSync, readFileSync, copyFileSync, mkdirSync, statSync, readdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync, statSync, readdirSync, renameSync, } from 'fs';
 import { join, relative, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { randomBytes } from 'crypto';
 import * as semver from 'semver';
 import * as ui from './ui.js';
 const __m_filename = fileURLToPath(import.meta.url);
@@ -20,7 +27,8 @@ const __m_dirname = dirname(__m_filename);
 const CLI_ROOT = resolve(__m_dirname, '..');
 const FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---/;
 const VERSION_RE = /^version:\s*["']?([0-9]+\.[0-9]+\.[0-9]+(?:-[A-Za-z0-9.-]+)?)["']?\s*$/m;
-function parseVersion(file) {
+const SV_VERSION_RE = /\/\/\s*@sv-version:\s*([0-9]+\.[0-9]+\.[0-9]+(?:-[A-Za-z0-9.-]+)?)/;
+function parseFrontmatterVersion(file) {
     if (!existsSync(file))
         return null;
     try {
@@ -35,7 +43,19 @@ function parseVersion(file) {
         return null;
     }
 }
-function statusOf(bundled, installed) {
+function parseHookVersion(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        const content = readFileSync(file, 'utf8').slice(0, 1024);
+        const m = SV_VERSION_RE.exec(content);
+        return m?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function statusFromSemver(bundled, installed) {
     if (installed === null)
         return 'modified-no-version';
     const cmp = semver.compare(installed, bundled);
@@ -62,11 +82,11 @@ function listSubdirs(dir) {
         return [];
     }
 }
-function listFiles(dir, suffix) {
+function listFiles(dir, suffixes) {
     if (!existsSync(dir))
         return [];
     try {
-        return readdirSync(dir).filter(n => n.endsWith(suffix));
+        return readdirSync(dir).filter(n => suffixes.some(s => n.endsWith(s)) && !n.startsWith('_state.README'));
     }
     catch {
         return [];
@@ -90,11 +110,16 @@ function listSkillSources(stack, frontendSkillsDir) {
 }
 function listAgentSources() {
     const dir = join(CLI_ROOT, 'stacks', '_shared', 'agents');
-    return listFiles(dir, '.md').map(n => ({ source: join(dir, n), name: n }));
+    return listFiles(dir, ['.md']).map(n => ({ source: join(dir, n), name: n }));
 }
 function listHookSources() {
     const dir = join(CLI_ROOT, 'stacks', '_shared', 'hooks');
-    return listFiles(dir, '.ts').map(n => ({ source: join(dir, n), name: n }));
+    // Track .ts and .sh files (runnable hooks + shared lib). _state.README.md is handled separately.
+    return listFiles(dir, ['.ts', '.sh']).map(n => ({ source: join(dir, n), name: n }));
+}
+function listCommandSources() {
+    const dir = join(CLI_ROOT, 'stacks', '_shared', 'commands');
+    return listFiles(dir, ['.md']).map(n => ({ source: join(dir, n), name: n }));
 }
 function loadProjectConfig(projectDir) {
     const path = join(projectDir, '.claude', 'config', 'active-project.json');
@@ -118,53 +143,223 @@ export function planMigration(projectDir, opts) {
     if (scope === 'all' || scope === 'skills') {
         for (const { source, name } of listSkillSources(config.stack, config.frontendSkillsDir)) {
             const target = join(projectDir, '.claude', 'skills', name, 'SKILL.md');
-            const bundledVersion = parseVersion(source);
+            const bundledVersion = parseFrontmatterVersion(source);
             if (!bundledVersion)
                 continue;
-            const installedVersion = parseVersion(target);
-            const status = !existsSync(target)
-                ? 'missing'
-                : statusOf(bundledVersion, installedVersion);
+            const installedVersion = parseFrontmatterVersion(target);
+            const status = !existsSync(target) ? 'missing' : statusFromSemver(bundledVersion, installedVersion);
             items.push({ kind: 'skill', name, source, target, bundledVersion, installedVersion, status });
         }
     }
     if (scope === 'all' || scope === 'agents') {
         for (const { source, name } of listAgentSources()) {
             const target = join(projectDir, '.claude', 'agents', name);
-            const bundledVersion = parseVersion(source);
+            const bundledVersion = parseFrontmatterVersion(source);
             if (!bundledVersion)
                 continue;
-            const installedVersion = parseVersion(target);
-            const status = !existsSync(target)
-                ? 'missing'
-                : statusOf(bundledVersion, installedVersion);
+            const installedVersion = parseFrontmatterVersion(target);
+            const status = !existsSync(target) ? 'missing' : statusFromSemver(bundledVersion, installedVersion);
             items.push({ kind: 'agent', name, source, target, bundledVersion, installedVersion, status });
         }
     }
     if (scope === 'all' || scope === 'hooks') {
         for (const { source, name } of listHookSources()) {
             const target = join(projectDir, '.claude', 'hooks', name);
-            const bundledVersion = '0.0.0';
-            const installedVersion = existsSync(target) ? '0.0.0' : null;
-            const status = !existsSync(target) ? 'missing' : 'current';
+            const bundledVersion = parseHookVersion(source) ?? '0.0.0';
+            const installedVersion = parseHookVersion(target);
+            let status;
+            if (!existsSync(target)) {
+                status = 'missing';
+            }
+            else if (installedVersion === null) {
+                status = bundledVersion === '0.0.0' ? 'current' : 'needs-update-legacy';
+            }
+            else {
+                status = statusFromSemver(bundledVersion, installedVersion);
+            }
             items.push({ kind: 'hook', name, source, target, bundledVersion, installedVersion, status });
         }
     }
+    if (scope === 'all' || scope === 'commands') {
+        for (const { source, name } of listCommandSources()) {
+            const target = join(projectDir, '.claude', 'commands', name);
+            const bundledVersion = parseFrontmatterVersion(source);
+            if (!bundledVersion)
+                continue;
+            const installedVersion = parseFrontmatterVersion(target);
+            let status;
+            if (!existsSync(target)) {
+                status = 'missing';
+            }
+            else if (installedVersion === null) {
+                // Commands are canonical infra files (slash-command routes). When the
+                // installed copy lacks `version:` frontmatter it predates versioned
+                // commands — treat as legacy so `--force-hooks` can heal it (same
+                // .bak machinery as legacy hooks). Skills/agents stay manual-review.
+                status = 'needs-update-legacy';
+            }
+            else {
+                status = statusFromSemver(bundledVersion, installedVersion);
+            }
+            items.push({ kind: 'command', name, source, target, bundledVersion, installedVersion, status });
+        }
+    }
     return items;
 }
-function applyOne(item) {
+function backup(target) {
+    if (!existsSync(target))
+        return null;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const dest = `${target}.${stamp}.bak`;
+    try {
+        copyFileSync(target, dest);
+        return dest;
+    }
+    catch {
+        return null;
+    }
+}
+function applyOne(item, opts) {
     mkdirSync(dirname(item.target), { recursive: true });
+    if (item.status === 'needs-update-legacy') {
+        if (!opts.forceHooks)
+            return { applied: false };
+        const backupPath = backup(item.target);
+        copyFileSync(item.source, item.target);
+        return { applied: true, backupPath };
+    }
     copyFileSync(item.source, item.target);
+    return { applied: true };
 }
+const REQUIRED_HOOK_BLOCKS = {
+    SessionStart: {
+        hooks: [
+            { type: 'command', command: 'npx tsx "$CLAUDE_PROJECT_DIR/.claude/hooks/session-start.ts"', timeout: 10 },
+        ],
+    },
+    UserPromptSubmit: {
+        matcher: '',
+        hooks: [
+            { type: 'command', command: 'npx tsx "$CLAUDE_PROJECT_DIR/.claude/hooks/user-prompt-submit.ts"', timeout: 10 },
+        ],
+    },
+    PreToolUse: {
+        matcher: 'Edit|Write|MultiEdit|NotebookEdit',
+        hooks: [
+            { type: 'command', command: 'npx tsx "$CLAUDE_PROJECT_DIR/.claude/hooks/pre-tool-use.ts"', timeout: 5 },
+        ],
+    },
+    PostToolUse: {
+        matcher: 'Edit|Write|MultiEdit|NotebookEdit',
+        hooks: [
+            { type: 'command', command: 'npx tsx "$CLAUDE_PROJECT_DIR/.claude/hooks/post-tool-use.ts"', timeout: 5 },
+        ],
+    },
+    Stop: {
+        hooks: [
+            { type: 'command', command: 'npx tsx "$CLAUDE_PROJECT_DIR/.claude/hooks/stop-validator.ts"', timeout: 30 },
+        ],
+    },
+    SessionEnd: {
+        hooks: [
+            { type: 'command', command: 'npx tsx "$CLAUDE_PROJECT_DIR/.claude/hooks/stop-validator.ts"', timeout: 10 },
+        ],
+    },
+};
+function commandSubstring(cmd) {
+    const m = cmd.match(/\.claude\/hooks\/([A-Za-z0-9._-]+\.(?:ts|sh|js|mjs))/);
+    return m?.[1] ?? cmd;
+}
+function writeFileAtomic(target, content) {
+    const tmp = `${target}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    writeFileSync(tmp, content);
+    renameSync(tmp, target);
+}
+export function patchSettings(projectDir, dryRun) {
+    const path = join(projectDir, '.claude', 'settings.json');
+    const report = { added: [], alreadyPresent: [], fileExisted: existsSync(path) };
+    let settings = {};
+    if (existsSync(path)) {
+        try {
+            settings = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch (err) {
+            report.error = `settings.json is not valid JSON (${err.message}) — skipping patch.`;
+            return report;
+        }
+    }
+    settings.hooks = settings.hooks || {};
+    for (const [event, requiredBlock] of Object.entries(REQUIRED_HOOK_BLOCKS)) {
+        const existingBlocks = Array.isArray(settings.hooks[event]) ? settings.hooks[event] : [];
+        const requiredScript = commandSubstring(requiredBlock.hooks[0].command);
+        const alreadyHas = existingBlocks.some(b => (b.hooks || []).some(h => commandSubstring(h.command).includes(requiredScript)));
+        if (alreadyHas) {
+            report.alreadyPresent.push(event);
+            continue;
+        }
+        if (!dryRun) {
+            settings.hooks[event] = [...existingBlocks, requiredBlock];
+        }
+        report.added.push(event);
+    }
+    if (!dryRun && report.added.length > 0 && !report.error) {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileAtomic(path, JSON.stringify(settings, null, '\t'));
+    }
+    return report;
+}
+export function ensureRuntimeArtefacts(projectDir, dryRun) {
+    const report = { created: [], copied: [], gitignoreUpdated: false };
+    const stateRoot = join(projectDir, '.claude', 'state');
+    const dirs = [
+        join(stateRoot, 'sessions', '_archive'),
+        join(stateRoot, 'inbox'),
+        join(stateRoot, 'file-touches', '_archive'),
+    ];
+    for (const d of dirs) {
+        if (!existsSync(d)) {
+            if (!dryRun)
+                mkdirSync(d, { recursive: true });
+            report.created.push(relative(projectDir, d));
+        }
+    }
+    const readmeSrc = join(CLI_ROOT, 'stacks', '_shared', 'hooks', '_state.README.md');
+    const readmeDest = join(stateRoot, 'README.md');
+    if (existsSync(readmeSrc) && !existsSync(readmeDest)) {
+        if (!dryRun) {
+            mkdirSync(dirname(readmeDest), { recursive: true });
+            copyFileSync(readmeSrc, readmeDest);
+        }
+        report.copied.push(relative(projectDir, readmeDest));
+    }
+    const giPath = join(projectDir, '.gitignore');
+    if (existsSync(giPath)) {
+        const gi = readFileSync(giPath, 'utf8');
+        const covered = /^\.claude\/state\/?$/m.test(gi) || /^\.claude\/?$/m.test(gi);
+        if (!covered) {
+            if (!dryRun) {
+                const next = gi.trimEnd() +
+                    '\n\n# Claude Code multi-instance coordination state (runtime, per-host)\n.claude/state/\n';
+                writeFileSync(giPath, next);
+            }
+            report.gitignoreUpdated = true;
+        }
+    }
+    return report;
+}
+/* ---------------------------------------------------------------------------
+ * CLI runner
+ * -------------------------------------------------------------------------*/
 export async function runMigrate(projectDir, opts) {
     ui.header('🔄 Start Vibing — Migrate');
     const items = planMigration(projectDir, opts);
-    if (items.length === 0) {
-        ui.info('Nothing to migrate.');
-        return;
-    }
     const grouped = {
-        missing: [], outdated: [], current: [], ahead: [], 'modified-no-version': [],
+        missing: [],
+        outdated: [],
+        current: [],
+        ahead: [],
+        'modified-no-version': [],
+        'needs-update-legacy': [],
     };
     for (const it of items)
         grouped[it.status].push(it);
@@ -174,44 +369,119 @@ export async function runMigrate(projectDir, opts) {
         console.log(`\n  ${label} (${list.length}):`);
         for (const it of list.slice(0, 30)) {
             const v = it.installedVersion ?? '–';
-            console.log(`    ${it.kind.padEnd(5)} ${it.name.padEnd(32)} installed=${v.padEnd(8)} bundled=${it.bundledVersion}`);
+            console.log(`    ${it.kind.padEnd(7)} ${it.name.padEnd(32)} installed=${v.padEnd(8)} bundled=${it.bundledVersion}`);
         }
         if (list.length > 30)
             console.log(`    ... and ${list.length - 30} more`);
     };
     summary('MISSING', grouped.missing);
     summary('OUTDATED', grouped.outdated);
+    summary('NEEDS UPDATE — legacy (hooks without @sv-version, commands without version: frontmatter)', grouped['needs-update-legacy']);
     summary('AHEAD (installed newer than bundled — kept)', grouped.ahead);
     summary('UNVERSIONED (manual review)', grouped['modified-no-version']);
     summary('CURRENT', grouped.current);
-    const upgradable = [...grouped.missing, ...grouped.outdated];
-    if (upgradable.length === 0) {
+    // Settings.json + runtime — preview always, regardless of items.
+    const settingsPreview = patchSettings(projectDir, true);
+    const runtimePreview = ensureRuntimeArtefacts(projectDir, true);
+    if (settingsPreview.added.length > 0) {
+        console.log('\n  SETTINGS.JSON — will add hook entries:');
+        for (const ev of settingsPreview.added)
+            console.log(`    + ${ev}`);
+    }
+    if (settingsPreview.error) {
+        console.log(`\n  SETTINGS.JSON — ${settingsPreview.error}`);
+    }
+    if (runtimePreview.created.length > 0) {
+        console.log('\n  RUNTIME — will create dirs:');
+        for (const d of runtimePreview.created)
+            console.log(`    + ${d}`);
+    }
+    if (runtimePreview.copied.length > 0) {
+        console.log('\n  RUNTIME — will copy:');
+        for (const f of runtimePreview.copied)
+            console.log(`    + ${f}`);
+    }
+    if (runtimePreview.gitignoreUpdated) {
+        console.log('\n  GITIGNORE — will append `.claude/state/`');
+    }
+    const upgradable = [
+        ...grouped.missing,
+        ...grouped.outdated,
+        ...(opts.forceHooks ? grouped['needs-update-legacy'] : []),
+    ];
+    const nothingFile = upgradable.length === 0;
+    const nothingSettings = settingsPreview.added.length === 0;
+    const nothingRuntime = runtimePreview.created.length === 0 && runtimePreview.copied.length === 0 && !runtimePreview.gitignoreUpdated;
+    if (nothingFile && nothingSettings && nothingRuntime) {
         console.log('');
         ui.success('Everything up to date.');
         return;
     }
     if (!opts.apply) {
         console.log('');
-        ui.info(`Run with --apply to install/update ${upgradable.length} item(s).`);
+        const todo = [];
+        if (upgradable.length > 0)
+            todo.push(`${upgradable.length} file(s)`);
+        if (settingsPreview.added.length > 0)
+            todo.push(`${settingsPreview.added.length} settings entry(ies)`);
+        if (!nothingRuntime)
+            todo.push('runtime artefacts');
+        ui.info(`Run with --apply to update: ${todo.join(' + ')}.`);
+        if (grouped['needs-update-legacy'].length > 0 && !opts.forceHooks) {
+            ui.info(`${grouped['needs-update-legacy'].length} legacy file(s) detected (hooks without @sv-version, ` +
+                `commands without \`version:\` frontmatter). Use --force-legacy (alias --force-hooks) to ` +
+                `update them with a .bak backup.`);
+        }
         return;
     }
     console.log('');
+    let updated = 0;
+    let legacyUpdated = 0;
     for (const it of upgradable) {
         try {
-            applyOne(it);
-            ui.success(`updated ${it.kind} ${it.name} (${it.installedVersion ?? '–'} → ${it.bundledVersion})`);
+            const r = applyOne(it, opts);
+            if (!r.applied)
+                continue;
+            updated++;
+            if (it.status === 'needs-update-legacy')
+                legacyUpdated++;
+            const bak = r.backupPath ? ` (backup: ${relative(projectDir, r.backupPath)})` : '';
+            ui.success(`updated ${it.kind} ${it.name} (${it.installedVersion ?? '–'} → ${it.bundledVersion})${bak}`);
         }
         catch (err) {
             ui.warn(`failed ${it.kind} ${it.name}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    // Apply settings + runtime.
+    const settingsApply = patchSettings(projectDir, false);
+    const runtimeApply = ensureRuntimeArtefacts(projectDir, false);
+    for (const ev of settingsApply.added)
+        ui.success(`settings.json: wired ${ev}`);
+    if (settingsApply.error)
+        ui.warn(settingsApply.error);
+    for (const d of runtimeApply.created)
+        ui.success(`runtime: created ${d}`);
+    for (const f of runtimeApply.copied)
+        ui.success(`runtime: copied ${f}`);
+    if (runtimeApply.gitignoreUpdated)
+        ui.success('gitignore: appended .claude/state/');
     console.log('');
-    ui.success(`Migration complete: ${upgradable.length} item(s) updated.`);
+    ui.success(`Migration complete: ${updated} file(s), ${settingsApply.added.length} settings entry(ies)` +
+        (legacyUpdated > 0 ? `, ${legacyUpdated} legacy file(s) overwritten with backup` : ''));
     if (grouped['modified-no-version'].length > 0) {
         console.log('');
-        ui.warn(`${grouped['modified-no-version'].length} unversioned local item(s) skipped — review manually.`);
+        ui.warn(`${grouped['modified-no-version'].length} unversioned local skill/agent/command(s) skipped — review manually.`);
         for (const it of grouped['modified-no-version'].slice(0, 10)) {
             console.log(`    ${relative(projectDir, it.target)}`);
         }
     }
+    if (grouped['needs-update-legacy'].length > 0 && !opts.forceHooks) {
+        console.log('');
+        ui.warn(`${grouped['needs-update-legacy'].length} legacy file(s) skipped (hooks without @sv-version, ` +
+            `commands without \`version:\` frontmatter). Re-run with --force-legacy ` +
+            `(alias --force-hooks) to update them (each gets a .bak backup).`);
+        for (const it of grouped['needs-update-legacy'].slice(0, 10)) {
+            console.log(`    ${relative(projectDir, it.target)}`);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-vibing-stacks",
-  "version": "2.23.0",
+  "version": "2.25.0",
   "description": "AI-powered multi-stack dev workflow for Claude Code. Supports PHP, Node.js, Python and more.",
   "type": "module",
   "bin": {

package/stacks/_shared/hooks/_state.ts

@@ -1,3 +1,4 @@
+// @sv-version: 1.0.0
 /**
  * Multi-Instance Coordination — Shared State Library
  *

package/stacks/_shared/hooks/final-check.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.0.0
 /**
  * Final Check — executable validator with VETO.
  *

package/stacks/_shared/hooks/peers.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.0.0
 /**
  * `peers` — CLI for the multi-instance coordination layer.
  *

package/stacks/_shared/hooks/post-tool-use.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.0.0
 /**
  * PostToolUse Hook — Multi-Instance Coordination
  *

package/stacks/_shared/hooks/pre-tool-use.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.0.0
 /**
  * PreToolUse Hook — Multi-Instance Coordination
  *

package/stacks/_shared/hooks/run-hook.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.0.0
 /**
  * Universal Hook Runner — Start Vibing Stacks
  *

package/stacks/_shared/hooks/session-start.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.0.0
 /**
  * SessionStart Hook — Multi-Instance Coordination
  *

package/stacks/_shared/hooks/stop-validator.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.1.0
 /**
  * Stop Validator Hook — Start Vibing Stacks (Universal)
  *

package/stacks/_shared/hooks/user-prompt-submit.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// @sv-version: 1.1.0
 /**
  * UserPromptSubmit Hook — Start Vibing Stacks
  *