@edcalderon/versioning 1.1.2 → 1.2.0

package/README.md

@@ -113,7 +113,7 @@ Features:
 - Local registry support
 - Dry-run mode
 
-#### Re-entry Status + Roadmap Extension
+### Re-entry Status + Roadmap Extension
 
 Maintains a fast **re-entry** layer (current state + next micro-step) and a slow **roadmap/backlog** layer (long-term plan).
 
@@ -129,39 +129,67 @@ Multi-project (scoped by `--project <name>`):
 - `.versioning/projects/<project>/REENTRY.md`
 - `.versioning/projects/<project>/ROADMAP.md`
 
-Notes:
-- `--project` must match an existing workspace app/package (it can be a slug like `trader`, a scoped package name like `@ed/trader`, or a path like `apps/trader`).
-- The canonical project key is the last path segment (e.g. `@ed/trader` → `trader`).
+**Smart Features:**
+- **Auto-Update:** `versioning reentry update` infers the project phase and next step from your last git commit.
+  - `feat: ...` → **Phase: development**
+  - `fix: ...` → **Phase: maintenance**
+- **Git Context:** Automatically links status to the latest branch, commit, and author.
 
 Commands:
 
 ```bash
 # Fast layer
 versioning reentry init
+versioning reentry update        # Auto-update status from git commit
+versioning reentry show          # Show current status summary
 versioning reentry sync
 
 # Fast layer (scoped)
 versioning reentry init --project trader
-versioning reentry sync --project trader
+versioning reentry update --project trader
+versioning reentry show --project trader
 
 # Slow layer
 versioning roadmap init --title "My Project"
 versioning roadmap list
 versioning roadmap set-milestone --id "now-01" --title "Ship X"
-versioning roadmap add --section Now --id "now-02" --item "Add observability"
+```
+
+#### Cleanup Repo Extension
 
-# Slow layer (scoped)
-versioning roadmap init --project trader --title "Trader"
-versioning roadmap list --project trader
-versioning roadmap add --project trader --section Now --item "Wire user-data ORDER_* events"
+Keeps your repository root clean by organizing stray files into appropriate directories (docs, scripts, config, archive).
+
+Features:
+- **Smart Scanning:** Identifies files that don't belong in the root.
+- **Configurable Routes:** Map extensions to folders (e.g. `.sh` → `scripts/`).
+- **Safety:** Allowlist for root files and Denylist for forced moves.
+- **Husky Integration:** Auto-scan or auto-move on commit.
 
-# Detect stale/mismatched scoped roadmaps
-versioning roadmap validate
+Commands:
+
+```bash
+versioning cleanup scan          # Dry-run scan of root
+versioning cleanup move          # Move files to configured destinations
+versioning cleanup restore       # Restore a moved file
+versioning cleanup config        # View/manage configuration
+versioning cleanup husky         # Setup git hook
 ```
 
-Backward compatibility:
-- v1.0 status files load safely.
-- Schema migrates to v1.1 only when you actually modify status, or explicitly via `versioning reentry sync --migrate`.
+Configuration (`versioning.config.json`):
+
+```json
+{
+  "cleanup": {
+    "enabled": true,
+    "defaultDestination": "docs",
+    "allowlist": ["CHANGELOG.md"],
+    "routes": {
+      ".sh": "scripts",
+      ".json": "config"
+    }
+  }
+}
+```
 
 ### External Extensions
 

package/dist/extensions/cleanup-repo-extension.d.ts

@@ -0,0 +1,49 @@
+import { VersioningExtension } from '../extensions';
+/**
+ * The canonical cleanup configuration schema.
+ * Everything the plugin needs lives here.
+ */
+export interface CleanupRepoConfig {
+    /** Master switch. Default: true */
+    enabled: boolean;
+    /** Default destination for files without a specific route. Default: "docs" */
+    defaultDestination: string;
+    /**
+     * Files explicitly allowed to stay in root (on top of built-in essentials).
+     * Supports exact filenames and glob-like patterns (e.g. "*.config.js").
+     */
+    allowlist: string[];
+    /**
+     * Files that should ALWAYS be moved, even if they match the allowlist.
+     * Useful for forcing cleanup of specific known offenders.
+     */
+    denylist: string[];
+    /**
+     * File extensions to consider for cleanup (with leading dot).
+     * Default: [".md", ".sh", ".json", ".yaml", ".yml", ".txt", ".log"]
+     */
+    extensions: string[];
+    /**
+     * Mapping of file extension → destination directory.
+     * Overrides defaultDestination per extension.
+     */
+    routes: Record<string, string>;
+    /**
+     * Husky integration settings.
+     */
+    husky: {
+        enabled: boolean;
+        /** Which husky hook to attach to. Default: "pre-commit" */
+        hook: string;
+        /** "scan" = warning only, "enforce" = auto-move + git add. Default: "scan" */
+        mode: 'scan' | 'enforce';
+    };
+}
+declare const BUILTIN_ALLOWLIST: Set<string>;
+declare const DEFAULT_EXTENSIONS: string[];
+declare const DEFAULT_ROUTES: Record<string, string>;
+declare function loadCleanupConfig(rootConfig: any): CleanupRepoConfig;
+declare const extension: VersioningExtension;
+export { loadCleanupConfig, BUILTIN_ALLOWLIST, DEFAULT_EXTENSIONS, DEFAULT_ROUTES };
+export default extension;
+//# sourceMappingURL=cleanup-repo-extension.d.ts.map

package/dist/extensions/cleanup-repo-extension.js

@@ -0,0 +1,641 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ROUTES = exports.DEFAULT_EXTENSIONS = exports.BUILTIN_ALLOWLIST = void 0;
+exports.loadCleanupConfig = loadCleanupConfig;
+const commander_1 = require("commander");
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const CLEANUP_EXTENSION_NAME = 'cleanup-repo';
+// ─────────────────────────────────────────────────────────────────
+//  BUILT-IN ESSENTIALS – these never get flagged
+// ─────────────────────────────────────────────────────────────────
+const BUILTIN_ALLOWLIST = new Set([
+    'package.json',
+    'pnpm-workspace.yaml',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'package-lock.json',
+    'bun.lockb',
+    'tsconfig.json',
+    'tsconfig.base.json',
+    '.gitignore',
+    '.gitattributes',
+    '.npmrc',
+    '.nvmrc',
+    '.node-version',
+    '.editorconfig',
+    '.eslintrc.js',
+    '.eslintrc.json',
+    '.eslintrc.cjs',
+    '.eslintrc.yaml',
+    'eslint.config.js',
+    'eslint.config.mjs',
+    '.prettierrc',
+    '.prettierrc.json',
+    '.prettierrc.js',
+    '.prettierrc.yaml',
+    '.prettierignore',
+    '.env',
+    '.env.example',
+    '.env.local',
+    '.envrc',
+    'LICENSE',
+    'README.md',
+    'Makefile',
+    'Dockerfile',
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    'firebase.json',
+    'firestore.rules',
+    'versioning.config.json',
+    'turbo.json',
+    'nx.json',
+    'lerna.json',
+    'biome.json',
+    'renovate.json',
+    '.releaserc.json',
+    'jest.config.js',
+    'jest.config.ts',
+    'vitest.config.ts',
+    'vitest.config.js',
+    'tailwind.config.js',
+    'tailwind.config.ts',
+    'postcss.config.js',
+    'postcss.config.mjs',
+    'next.config.js',
+    'next.config.mjs',
+    'vite.config.ts',
+    'vite.config.js',
+]);
+exports.BUILTIN_ALLOWLIST = BUILTIN_ALLOWLIST;
+// ─────────────────────────────────────────────────────────────────
+//  DEFAULTS
+// ─────────────────────────────────────────────────────────────────
+const DEFAULT_EXTENSIONS = ['.md', '.sh', '.json', '.yaml', '.yml', '.txt', '.log'];
+exports.DEFAULT_EXTENSIONS = DEFAULT_EXTENSIONS;
+const DEFAULT_ROUTES = {
+    '.md': 'docs',
+    '.sh': 'scripts',
+    '.json': 'config',
+    '.yaml': 'config',
+    '.yml': 'config',
+    '.txt': 'archive',
+    '.log': 'archive',
+};
+exports.DEFAULT_ROUTES = DEFAULT_ROUTES;
+// ─────────────────────────────────────────────────────────────────
+//  CONFIG LOADER
+// ─────────────────────────────────────────────────────────────────
+function loadCleanupConfig(rootConfig) {
+    const raw = rootConfig?.cleanup ?? {};
+    return {
+        enabled: raw.enabled !== false,
+        defaultDestination: typeof raw.defaultDestination === 'string' ? raw.defaultDestination : 'docs',
+        allowlist: Array.isArray(raw.allowlist) ? raw.allowlist : [],
+        denylist: Array.isArray(raw.denylist) ? raw.denylist : [],
+        extensions: Array.isArray(raw.extensions) ? raw.extensions.map((e) => e.startsWith('.') ? e : `.${e}`) : DEFAULT_EXTENSIONS,
+        routes: typeof raw.routes === 'object' && raw.routes !== null ? raw.routes : DEFAULT_ROUTES,
+        husky: {
+            enabled: raw.husky?.enabled === true,
+            hook: typeof raw.husky?.hook === 'string' ? raw.husky.hook : 'pre-commit',
+            mode: raw.husky?.mode === 'enforce' ? 'enforce' : 'scan',
+        },
+    };
+}
+// ─────────────────────────────────────────────────────────────────
+//  MATCHING HELPERS
+// ─────────────────────────────────────────────────────────────────
+/** Simple glob matching: supports exact names and "*.ext" patterns. */
+function matchesPattern(filename, pattern) {
+    if (pattern === filename)
+        return true;
+    if (pattern.startsWith('*.')) {
+        const ext = pattern.slice(1); // e.g. ".config.js"
+        return filename.endsWith(ext);
+    }
+    if (pattern.endsWith('*')) {
+        const prefix = pattern.slice(0, -1);
+        return filename.startsWith(prefix);
+    }
+    return false;
+}
+function isAllowed(filename, config) {
+    // Built-in essentials always allowed
+    if (BUILTIN_ALLOWLIST.has(filename))
+        return true;
+    // Check user allowlist from config
+    for (const pattern of config.allowlist) {
+        if (matchesPattern(filename, pattern))
+            return true;
+    }
+    return false;
+}
+function isDenied(filename, config) {
+    for (const pattern of config.denylist) {
+        if (matchesPattern(filename, pattern))
+            return true;
+    }
+    return false;
+}
+function getDestination(filename, ext, config) {
+    // Check extension routes from config
+    if (config.routes[ext])
+        return config.routes[ext];
+    return config.defaultDestination;
+}
+function getReason(filename, ext, dest) {
+    const typeMap = {
+        '.md': 'Markdown file',
+        '.sh': 'Shell script',
+        '.json': 'JSON config file',
+        '.yaml': 'YAML file',
+        '.yml': 'YAML file',
+        '.txt': 'Text file',
+        '.log': 'Log file',
+    };
+    const type = typeMap[ext] || 'File';
+    return `${type} "${filename}" should live in ${dest}/`;
+}
+async function scanRootForCleanup(rootDir, config) {
+    const candidates = [];
+    const extensionSet = new Set(config.extensions);
+    const entries = await fs.readdir(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory())
+            continue;
+        const name = entry.name;
+        // Skip hidden dotfiles unless they match a cleanup extension
+        const ext = path.extname(name).toLowerCase();
+        if (name.startsWith('.') && !extensionSet.has(ext))
+            continue;
+        // Denylist check — always flag these, even if allowlisted
+        const denied = isDenied(name, config);
+        if (!denied) {
+            // Skip allowlisted files
+            if (isAllowed(name, config))
+                continue;
+            // Check if this extension is a cleanup candidate
+            if (!extensionSet.has(ext))
+                continue;
+        }
+        const filePath = path.join(rootDir, name);
+        const stat = await fs.stat(filePath);
+        const dest = getDestination(name, ext, config);
+        const reason = denied
+            ? `"${name}" is in the denylist → forced move to ${dest}/`
+            : getReason(name, ext, dest);
+        candidates.push({
+            file: name,
+            ext,
+            sizeBytes: stat.size,
+            reason,
+            destination: dest,
+            isDenied: denied,
+        });
+    }
+    return candidates;
+}
+// ─────────────────────────────────────────────────────────────────
+//  EXTENSION
+// ─────────────────────────────────────────────────────────────────
+const extension = {
+    name: CLEANUP_EXTENSION_NAME,
+    description: 'Config-driven repo root cleanup — keeps stray files out of root, configurable via versioning.config.json',
+    version: '1.1.0',
+    register: async (program, rootConfig) => {
+        const config = loadCleanupConfig(rootConfig);
+        const cleanupCmd = program
+            .command('cleanup')
+            .description('Repository root cleanup utilities (config: versioning.config.json → cleanup)');
+        // ── versioning cleanup scan ──────────────────────────────────
+        cleanupCmd.addCommand(new commander_1.Command('scan')
+            .description('Scan the repository root for files that should be moved')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .action(async (options) => {
+            // Reload config in case user passed a different config file
+            const cfg = await reloadConfig(options.config);
+            const rootDir = process.cwd();
+            if (!cfg.enabled) {
+                console.log('ℹ️  Cleanup is disabled in versioning.config.json (cleanup.enabled = false)');
+                return;
+            }
+            const candidates = await scanRootForCleanup(rootDir, cfg);
+            if (candidates.length === 0) {
+                console.log('\n✅ Repository root is clean! No files need to be moved.\n');
+                return;
+            }
+            console.log('\n🔍 Repository Root Cleanup Scan\n');
+            console.log(`  Config: versioning.config.json → cleanup`);
+            console.log(`  Default destination: ${cfg.defaultDestination}/`);
+            console.log(`  Extensions monitored: ${cfg.extensions.join(', ')}`);
+            console.log(`  Allowlist (custom): ${cfg.allowlist.length > 0 ? cfg.allowlist.join(', ') : '—'}`);
+            console.log(`  Denylist: ${cfg.denylist.length > 0 ? cfg.denylist.join(', ') : '—'}`);
+            console.log(`\nFound ${candidates.length} file(s) that should be moved:\n`);
+            for (const c of candidates) {
+                const size = c.sizeBytes > 1024 ? `${(c.sizeBytes / 1024).toFixed(1)}KB` : `${c.sizeBytes}B`;
+                const badge = c.isDenied ? ' 🚫 DENIED' : '';
+                console.log(`  📄 ${c.file} (${size})${badge}`);
+                console.log(`     → ${c.destination}/${c.file}`);
+                console.log(`     ℹ️  ${c.reason}\n`);
+            }
+            console.log('  Run `versioning cleanup move` to move these files.');
+            console.log('  Edit versioning.config.json → cleanup.allowlist to keep specific files in root.\n');
+        }));
+        // ── versioning cleanup move ──────────────────────────────────
+        cleanupCmd.addCommand(new commander_1.Command('move')
+            .description('Move stray files from root to their configured destinations')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-d, --dest <path>', 'Override default destination directory')
+            .option('--force', 'Overwrite files at destination', false)
+            .option('--dry-run', 'Show what would happen without moving', false)
+            .option('--git-add', 'Stage moves with git after moving', false)
+            .action(async (options) => {
+            const cfg = await reloadConfig(options.config);
+            const rootDir = process.cwd();
+            if (!cfg.enabled) {
+                console.log('ℹ️  Cleanup is disabled in config.');
+                return;
+            }
+            // Override default destination if passed via CLI
+            if (options.dest) {
+                cfg.defaultDestination = options.dest;
+            }
+            const candidates = await scanRootForCleanup(rootDir, cfg);
+            if (candidates.length === 0) {
+                console.log('\n✅ Repository root is already clean!\n');
+                return;
+            }
+            console.log(`\n🧹 Moving ${candidates.length} file(s) from root…\n`);
+            const moved = [];
+            for (const c of candidates) {
+                const destDir = path.join(rootDir, c.destination);
+                const srcPath = path.join(rootDir, c.file);
+                const destPath = path.join(destDir, c.file);
+                if (options.dryRun) {
+                    console.log(`  [dry-run] ${c.file} → ${c.destination}/${c.file}`);
+                    continue;
+                }
+                try {
+                    await fs.ensureDir(destDir);
+                    if (await fs.pathExists(destPath)) {
+                        if (!options.force) {
+                            console.log(`  ⚠️  Skipped ${c.file} (already exists at ${c.destination}/${c.file})`);
+                            continue;
+                        }
+                    }
+                    await fs.move(srcPath, destPath, { overwrite: options.force });
+                    moved.push(c.file);
+                    console.log(`  ✅ ${c.file} → ${c.destination}/${c.file}`);
+                }
+                catch (error) {
+                    console.error(`  ❌ Failed to move ${c.file}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            if (options.gitAdd && moved.length > 0 && !options.dryRun) {
+                try {
+                    const git = (0, simple_git_1.default)();
+                    await git.add('.');
+                    console.log(`\n📦 Staged ${moved.length} moved file(s) with git.`);
+                }
+                catch (error) {
+                    console.warn(`\n⚠️  Could not stage changes: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            if (!options.dryRun) {
+                console.log(`\n✅ Moved ${moved.length}/${candidates.length} file(s). Root is cleaner!\n`);
+            }
+            else {
+                console.log(`\n📋 Dry run complete. ${candidates.length} file(s) would be moved.\n`);
+            }
+        }));
+        // ── versioning cleanup restore ───────────────────────────────
+        cleanupCmd.addCommand(new commander_1.Command('restore')
+            .description('Restore a previously moved file back to root')
+            .requiredOption('--file <name>', 'File name to restore')
+            .option('--from <path>', 'Source directory to restore from (auto-detects from routes if omitted)')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .action(async (options) => {
+            const cfg = await reloadConfig(options.config);
+            const rootDir = process.cwd();
+            // Auto-detect source from configured routes if --from not specified
+            let fromDir = options.from;
+            if (!fromDir) {
+                const ext = path.extname(options.file).toLowerCase();
+                fromDir = cfg.routes[ext] || cfg.defaultDestination;
+            }
+            const srcPath = path.join(rootDir, fromDir, options.file);
+            const destPath = path.join(rootDir, options.file);
+            if (!(await fs.pathExists(srcPath))) {
+                console.error(`❌ File not found: ${srcPath}`);
+                process.exit(1);
+            }
+            if (await fs.pathExists(destPath)) {
+                console.error(`❌ File already exists in root: ${options.file}`);
+                process.exit(1);
+            }
+            await fs.move(srcPath, destPath);
+            console.log(`✅ Restored ${fromDir}/${options.file} → ${options.file}`);
+        }));
+        // ── versioning cleanup config ────────────────────────────────
+        cleanupCmd.addCommand(new commander_1.Command('config')
+            .description('View or manage the cleanup configuration in versioning.config.json')
+            .option('--show', 'Show the full resolved cleanup config', false)
+            .option('--allow <file>', 'Add a file to the allowlist')
+            .option('--deny <file>', 'Add a file to the denylist')
+            .option('--unallow <file>', 'Remove a file from the allowlist')
+            .option('--undeny <file>', 'Remove a file from the denylist')
+            .option('--route <mapping>', 'Add extension route (format: ".ext=destination")')
+            .option('--set-dest <path>', 'Set the default destination directory')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .action(async (options) => {
+            const configPath = String(options.config);
+            let rawCfg = {};
+            if (await fs.pathExists(configPath)) {
+                rawCfg = await fs.readJson(configPath);
+            }
+            // Ensure cleanup section exists
+            if (!rawCfg.cleanup)
+                rawCfg.cleanup = {};
+            if (!Array.isArray(rawCfg.cleanup.allowlist))
+                rawCfg.cleanup.allowlist = [];
+            if (!Array.isArray(rawCfg.cleanup.denylist))
+                rawCfg.cleanup.denylist = [];
+            if (!rawCfg.cleanup.routes)
+                rawCfg.cleanup.routes = { ...DEFAULT_ROUTES };
+            if (!rawCfg.cleanup.extensions)
+                rawCfg.cleanup.extensions = [...DEFAULT_EXTENSIONS];
+            let modified = false;
+            // ── --allow
+            if (options.allow) {
+                const file = String(options.allow).trim();
+                if (!rawCfg.cleanup.allowlist.includes(file)) {
+                    rawCfg.cleanup.allowlist.push(file);
+                    modified = true;
+                    console.log(`✅ Added "${file}" to cleanup.allowlist`);
+                }
+                else {
+                    console.log(`ℹ️  "${file}" is already in the allowlist.`);
+                }
+            }
+            // ── --deny
+            if (options.deny) {
+                const file = String(options.deny).trim();
+                if (!rawCfg.cleanup.denylist.includes(file)) {
+                    rawCfg.cleanup.denylist.push(file);
+                    modified = true;
+                    console.log(`✅ Added "${file}" to cleanup.denylist`);
+                }
+                else {
+                    console.log(`ℹ️  "${file}" is already in the denylist.`);
+                }
+            }
+            // ── --unallow
+            if (options.unallow) {
+                const file = String(options.unallow).trim();
+                const idx = rawCfg.cleanup.allowlist.indexOf(file);
+                if (idx !== -1) {
+                    rawCfg.cleanup.allowlist.splice(idx, 1);
+                    modified = true;
+                    console.log(`✅ Removed "${file}" from cleanup.allowlist`);
+                }
+                else {
+                    console.log(`ℹ️  "${file}" is not in the allowlist.`);
+                }
+            }
+            // ── --undeny
+            if (options.undeny) {
+                const file = String(options.undeny).trim();
+                const idx = rawCfg.cleanup.denylist.indexOf(file);
+                if (idx !== -1) {
+                    rawCfg.cleanup.denylist.splice(idx, 1);
+                    modified = true;
+                    console.log(`✅ Removed "${file}" from cleanup.denylist`);
+                }
+                else {
+                    console.log(`ℹ️  "${file}" is not in the denylist.`);
+                }
+            }
+            // ── --route
+            if (options.route) {
+                const mapping = String(options.route).trim();
+                const eqIdx = mapping.indexOf('=');
+                if (eqIdx === -1) {
+                    console.error('❌ Route format must be ".ext=destination" (e.g. ".md=docs")');
+                    process.exit(1);
+                }
+                let ext = mapping.slice(0, eqIdx).trim();
+                const dest = mapping.slice(eqIdx + 1).trim();
+                if (!ext.startsWith('.'))
+                    ext = `.${ext}`;
+                rawCfg.cleanup.routes[ext] = dest;
+                modified = true;
+                console.log(`✅ Added route: ${ext} → ${dest}/`);
+            }
+            // ── --set-dest
+            if (options.setDest) {
+                rawCfg.cleanup.defaultDestination = String(options.setDest).trim();
+                modified = true;
+                console.log(`✅ Default destination set to "${rawCfg.cleanup.defaultDestination}"`);
+            }
+            // Write config if modified
+            if (modified) {
+                await fs.writeJson(configPath, rawCfg, { spaces: 2 });
+                console.log(`\n📝 Updated ${configPath}`);
+            }
+            // ── --show or no flags
+            if (options.show || (!options.allow && !options.deny && !options.unallow && !options.undeny && !options.route && !options.setDest)) {
+                const resolved = loadCleanupConfig(rawCfg);
+                console.log('\n┌─────────────────────────────────────────────────┐');
+                console.log('│     🧹 Cleanup-Repo Configuration                │');
+                console.log('├─────────────────────────────────────────────────┤');
+                console.log(`│  Enabled:           ${String(resolved.enabled).padEnd(28)}│`);
+                console.log(`│  Default dest:      ${resolved.defaultDestination.padEnd(28)}│`);
+                console.log('│                                                 │');
+                console.log('│  📋 Extensions monitored:                       │');
+                for (const ext of resolved.extensions) {
+                    const route = resolved.routes[ext] || resolved.defaultDestination;
+                    console.log(`│    ${ext.padEnd(8)} → ${route.padEnd(34)}│`);
+                }
+                console.log('│                                                 │');
+                console.log('│  ✅ Allowlist (custom):                          │');
+                if (resolved.allowlist.length === 0) {
+                    console.log('│    (none)                                       │');
+                }
+                else {
+                    for (const f of resolved.allowlist) {
+                        console.log(`│    + ${f.padEnd(42)}│`);
+                    }
+                }
+                console.log('│                                                 │');
+                console.log('│  🚫 Denylist (force-move):                       │');
+                if (resolved.denylist.length === 0) {
+                    console.log('│    (none)                                       │');
+                }
+                else {
+                    for (const f of resolved.denylist) {
+                        console.log(`│    - ${f.padEnd(42)}│`);
+                    }
+                }
+                console.log('│                                                 │');
+                console.log(`│  🔗 Husky integration: ${String(resolved.husky.enabled).padEnd(25)}│`);
+                if (resolved.husky.enabled) {
+                    console.log(`│    Hook: ${resolved.husky.hook.padEnd(39)}│`);
+                    console.log(`│    Mode: ${resolved.husky.mode.padEnd(39)}│`);
+                }
+                console.log('│                                                 │');
+                console.log('│  📦 Built-in essentials (always kept):           │');
+                const builtinArr = Array.from(BUILTIN_ALLOWLIST).sort().slice(0, 8);
+                for (const f of builtinArr) {
+                    console.log(`│    ✓ ${f.padEnd(42)}│`);
+                }
+                console.log(`│    … and ${BUILTIN_ALLOWLIST.size - builtinArr.length} more                                │`);
+                console.log('└─────────────────────────────────────────────────┘\n');
+            }
+        }));
+        // ── versioning cleanup husky ─────────────────────────────────
+        cleanupCmd.addCommand(new commander_1.Command('husky')
+            .description('Set up Husky hooks to auto-run cleanup on each commit')
+            .option('--remove', 'Remove cleanup from Husky hook', false)
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .action(async (options) => {
+            const cfg = await reloadConfig(options.config);
+            const rootDir = process.cwd();
+            const huskyDir = path.join(rootDir, '.husky');
+            const hookName = cfg.husky.hook;
+            const hookPath = path.join(huskyDir, hookName);
+            const CLEANUP_MARKER_START = '# === cleanup-repo: start ===';
+            const CLEANUP_MARKER_END = '# === cleanup-repo: end ===';
+            if (options.remove) {
+                if (!(await fs.pathExists(hookPath))) {
+                    console.log(`ℹ️  Hook ${hookName} does not exist.`);
+                    return;
+                }
+                const content = await fs.readFile(hookPath, 'utf8');
+                const startIdx = content.indexOf(CLEANUP_MARKER_START);
+                const endIdx = content.indexOf(CLEANUP_MARKER_END);
+                if (startIdx === -1 || endIdx === -1) {
+                    console.log(`ℹ️  No cleanup block found in ${hookName}.`);
+                    return;
+                }
+                const before = content.slice(0, startIdx).trimEnd();
+                const after = content.slice(endIdx + CLEANUP_MARKER_END.length).trimStart();
+                const updated = [before, '', after].join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+                await fs.writeFile(hookPath, updated, 'utf8');
+                // Also update config
+                await updateHuskyConfig(options.config, false);
+                console.log(`✅ Removed cleanup block from .husky/${hookName}`);
+                return;
+            }
+            // Add cleanup block to hook
+            await fs.ensureDir(huskyDir);
+            const cleanupBlock = cfg.husky.mode === 'enforce'
+                ? [
+                    '',
+                    CLEANUP_MARKER_START,
+                    'echo "🧹 Running root cleanup (enforce mode)…"',
+                    'npx versioning cleanup move --force --git-add 2>/dev/null || true',
+                    CLEANUP_MARKER_END,
+                    ''
+                ].join('\n')
+                : [
+                    '',
+                    CLEANUP_MARKER_START,
+                    'echo "🔍 Running root cleanup scan…"',
+                    'npx versioning cleanup scan 2>/dev/null || true',
+                    CLEANUP_MARKER_END,
+                    ''
+                ].join('\n');
+            if (await fs.pathExists(hookPath)) {
+                const existing = await fs.readFile(hookPath, 'utf8');
+                if (existing.includes(CLEANUP_MARKER_START)) {
+                    console.log(`ℹ️  Cleanup is already integrated in .husky/${hookName}.`);
+                    console.log('    Use --remove to uninstall, then re-add.');
+                    return;
+                }
+                const updated = existing.trimEnd() + '\n' + cleanupBlock;
+                await fs.writeFile(hookPath, updated, 'utf8');
+            }
+            else {
+                const content = [
+                    '#!/bin/sh',
+                    '. "$(dirname "$0")/_/husky.sh"',
+                    '',
+                    cleanupBlock
+                ].join('\n');
+                await fs.writeFile(hookPath, content, { mode: 0o755 });
+            }
+            // Also update config
+            await updateHuskyConfig(options.config, true, hookName, cfg.husky.mode);
+            const mode = cfg.husky.mode === 'enforce' ? 'enforce (auto-move + git-add)' : 'scan (warning only)';
+            console.log(`✅ Cleanup integrated into .husky/${hookName} [${mode}]`);
+            console.log(`   Configure mode in versioning.config.json → cleanup.husky.mode`);
+        }));
+    }
+};
+// ─────────────────────────────────────────────────────────────────
+//  HELPER: reload config from disk
+// ─────────────────────────────────────────────────────────────────
+async function reloadConfig(configPath) {
+    const fullPath = String(configPath);
+    if (await fs.pathExists(fullPath)) {
+        const raw = await fs.readJson(fullPath);
+        return loadCleanupConfig(raw);
+    }
+    return loadCleanupConfig({});
+}
+async function updateHuskyConfig(configPath, enabled, hook, mode) {
+    const fullPath = String(configPath);
+    let rawCfg = {};
+    if (await fs.pathExists(fullPath)) {
+        rawCfg = await fs.readJson(fullPath);
+    }
+    if (!rawCfg.cleanup)
+        rawCfg.cleanup = {};
+    if (!rawCfg.cleanup.husky)
+        rawCfg.cleanup.husky = {};
+    rawCfg.cleanup.husky.enabled = enabled;
+    if (hook)
+        rawCfg.cleanup.husky.hook = hook;
+    if (mode)
+        rawCfg.cleanup.husky.mode = mode;
+    await fs.writeJson(fullPath, rawCfg, { spaces: 2 });
+}
+exports.default = extension;
+//# sourceMappingURL=cleanup-repo-extension.js.map

package/dist/extensions/reentry-status/git-context.d.ts

@@ -0,0 +1,27 @@
+export interface GitContextInfo {
+    branch: string;
+    commit: string;
+    commitMessage: string;
+    author: string;
+    timestamp: string;
+    changedFiles: string[];
+    diffSummary: {
+        insertions: number;
+        deletions: number;
+        filesChanged: number;
+    };
+}
+/**
+ * Collects the current git context automatically from the working directory.
+ * This is used to auto-fill the reentry status with real git data.
+ */
+export declare function collectGitContext(): Promise<GitContextInfo>;
+/**
+ * Infer the current project phase based on git data and recent changes.
+ */
+export declare function inferPhase(context: GitContextInfo, currentVersion: string): string;
+/**
+ * Generate a suggested next step based on the last commit context.
+ */
+export declare function suggestNextStep(context: GitContextInfo): string;
+//# sourceMappingURL=git-context.d.ts.map

package/dist/extensions/reentry-status/git-context.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectGitContext = collectGitContext;
+exports.inferPhase = inferPhase;
+exports.suggestNextStep = suggestNextStep;
+const simple_git_1 = __importDefault(require("simple-git"));
+/**
+ * Collects the current git context automatically from the working directory.
+ * This is used to auto-fill the reentry status with real git data.
+ */
+async function collectGitContext() {
+    const git = (0, simple_git_1.default)();
+    try {
+        const [log, branch, diff] = await Promise.all([
+            git.log({ maxCount: 1 }),
+            git.branch(),
+            git.diffSummary(['HEAD~1', 'HEAD']).catch(() => null),
+        ]);
+        const latest = log.latest;
+        const statusResult = await git.status();
+        return {
+            branch: branch.current || '',
+            commit: latest?.hash?.substring(0, 7) || '',
+            commitMessage: latest?.message || '',
+            author: latest?.author_name || '',
+            timestamp: latest?.date || new Date().toISOString(),
+            changedFiles: statusResult.files.map(f => f.path),
+            diffSummary: {
+                insertions: diff?.insertions ?? 0,
+                deletions: diff?.deletions ?? 0,
+                filesChanged: diff?.changed ?? 0,
+            },
+        };
+    }
+    catch {
+        return {
+            branch: '',
+            commit: '',
+            commitMessage: '',
+            author: '',
+            timestamp: new Date().toISOString(),
+            changedFiles: [],
+            diffSummary: { insertions: 0, deletions: 0, filesChanged: 0 },
+        };
+    }
+}
+/**
+ * Infer the current project phase based on git data and recent changes.
+ */
+function inferPhase(context, currentVersion) {
+    const msg = context.commitMessage.toLowerCase();
+    if (msg.startsWith('fix:') || msg.startsWith('hotfix:') || msg.includes('bugfix')) {
+        return 'maintenance';
+    }
+    if (msg.startsWith('test:') || msg.includes('test')) {
+        return 'testing';
+    }
+    if (msg.startsWith('feat:') || msg.startsWith('feature:')) {
+        return 'development';
+    }
+    if (msg.startsWith('chore: release') || msg.includes('deploy') || msg.includes('staging')) {
+        return 'staging';
+    }
+    if (msg.startsWith('docs:') || msg.startsWith('chore:')) {
+        return 'maintenance';
+    }
+    return 'development';
+}
+/**
+ * Generate a suggested next step based on the last commit context.
+ */
+function suggestNextStep(context) {
+    const msg = context.commitMessage.toLowerCase();
+    if (msg.startsWith('feat:')) {
+        return `Write tests for: ${context.commitMessage.replace(/^feat:\s*/i, '').substring(0, 60)}`;
+    }
+    if (msg.startsWith('fix:')) {
+        return `Verify fix and add regression test for: ${context.commitMessage.replace(/^fix:\s*/i, '').substring(0, 50)}`;
+    }
+    if (msg.startsWith('test:')) {
+        return 'Review test coverage and consider edge cases';
+    }
+    if (msg.startsWith('chore: release')) {
+        return 'Verify deployment and update documentation';
+    }
+    if (msg.startsWith('docs:')) {
+        return 'Continue with next feature or bugfix';
+    }
+    return `Review changes from: ${context.commitMessage.substring(0, 60)}`;
+}
+//# sourceMappingURL=git-context.js.map

package/dist/extensions/reentry-status/index.d.ts

@@ -9,6 +9,7 @@ export * from './obsidian-sync-adapter';
 export * from './obsidian-cli-client';
 export * from './roadmap-parser';
 export * from './roadmap-renderer';
+export * from './git-context';
 export * from './reentry-status-manager';
 export * from './status-renderer';
 //# sourceMappingURL=index.d.ts.map

package/dist/extensions/reentry-status/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./obsidian-sync-adapter"), exports);
 __exportStar(require("./obsidian-cli-client"), exports);
 __exportStar(require("./roadmap-parser"), exports);
 __exportStar(require("./roadmap-renderer"), exports);
+__exportStar(require("./git-context"), exports);
 __exportStar(require("./reentry-status-manager"), exports);
 __exportStar(require("./status-renderer"), exports);
 //# sourceMappingURL=index.js.map

package/dist/extensions/reentry-status/roadmap-renderer.d.ts

@@ -3,9 +3,16 @@ export declare const ROADMAP_MANAGED_START = "<!-- roadmap:managed:start -->";
 export declare const ROADMAP_MANAGED_END = "<!-- roadmap:managed:end -->";
 export interface RoadmapRenderOptions {
     projectTitle?: string;
+    projectSlug?: string;
+    monorepoName?: string;
 }
 export declare class RoadmapRenderer {
     static defaultRoadmapPath(baseDir?: string): string;
+    /**
+     * Extract the project name from the roadmap file path for auto-identification.
+     * e.g. ".versioning/projects/trader/ROADMAP.md" → "trader"
+     */
+    static extractProjectFromPath(roadmapFile: string): string | null;
     static renderManagedBlock(status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
     static renderTemplate(options?: RoadmapRenderOptions, status?: Pick<ReentryStatus, 'milestone' | 'roadmapFile'>): string;
     /**

package/dist/extensions/reentry-status/roadmap-renderer.js

@@ -8,28 +8,45 @@ class RoadmapRenderer {
     static defaultRoadmapPath(baseDir = constants_1.REENTRY_STATUS_DIRNAME) {
         return `${baseDir}/${constants_1.ROADMAP_MD_FILENAME}`;
     }
+    /**
+     * Extract the project name from the roadmap file path for auto-identification.
+     * e.g. ".versioning/projects/trader/ROADMAP.md" → "trader"
+     */
+    static extractProjectFromPath(roadmapFile) {
+        const normalized = roadmapFile.replace(/\\/g, '/');
+        const match = /\.versioning\/projects\/([^/]+)\/ROADMAP\.md$/.exec(normalized);
+        return match ? match[1] : null;
+    }
     static renderManagedBlock(status) {
         const milestoneText = status?.milestone
             ? `${status.milestone.title} (id: ${status.milestone.id})`
             : '—';
         const roadmapFile = status?.roadmapFile ?? RoadmapRenderer.defaultRoadmapPath();
-        // Keep this block stable: no timestamps.
-        return [
+        const projectSlug = RoadmapRenderer.extractProjectFromPath(roadmapFile);
+        // Build the managed block with project identification
+        const lines = [
             exports.ROADMAP_MANAGED_START,
             '> Managed by `@edcalderon/versioning` reentry-status-extension.',
             `> Canonical roadmap file: ${roadmapFile}`,
-            `> Active milestone: ${milestoneText}`,
-            '> ',
-            '> Everything outside this block is user-editable.',
-            exports.ROADMAP_MANAGED_END,
-            ''
-        ].join('\n');
+        ];
+        if (projectSlug) {
+            lines.push(`> Project: **${projectSlug}**`);
+        }
+        lines.push(`> Active milestone: ${milestoneText}`, '> ', '> Everything outside this block is user-editable.', exports.ROADMAP_MANAGED_END, '');
+        return lines.join('\n');
     }
     static renderTemplate(options = {}, status) {
         const title = options.projectTitle?.trim() ? options.projectTitle.trim() : 'Untitled';
+        const roadmapFile = status?.roadmapFile ?? RoadmapRenderer.defaultRoadmapPath();
+        const projectSlug = options.projectSlug || RoadmapRenderer.extractProjectFromPath(roadmapFile);
+        const monorepo = options.monorepoName || '@ed/monorepo';
+        const headerLines = [`# Project Roadmap – ${title}`, ''];
+        // Add project metadata section
+        if (projectSlug) {
+            headerLines.push(`> 📦 **Project:** \`${projectSlug}\` | **Monorepo:** \`${monorepo}\``, '');
+        }
         return [
-            `# Project Roadmap – ${title}`,
-            '',
+            ...headerLines,
             RoadmapRenderer.renderManagedBlock(status),
             '## North Star',
             '',

package/dist/extensions/reentry-status-extension.js

@@ -48,14 +48,14 @@ const roadmap_parser_1 = require("./reentry-status/roadmap-parser");
 const roadmap_renderer_1 = require("./reentry-status/roadmap-renderer");
 const status_renderer_1 = require("./reentry-status/status-renderer");
 const reentry_status_manager_1 = require("./reentry-status/reentry-status-manager");
+const git_context_1 = require("./reentry-status/git-context");
 const extension = {
     name: constants_1.REENTRY_EXTENSION_NAME,
     description: 'Maintains canonical re-entry status and synchronizes to files, GitHub Issues, and Obsidian notes',
-    version: '1.1.2',
+    version: '1.2.0',
     hooks: {
         postVersion: async (type, version, options) => {
             try {
-                // Extensions are loaded before the CLI reads config per-command; use global config snapshot.
                 const configPath = options?.config ?? 'versioning.config.json';
                 if (!(await fs.pathExists(configPath)))
                     return;
@@ -65,15 +65,42 @@ const extension = {
                     return;
                 if (reentryCfg.hooks?.postVersion === false)
                     return;
+                // Auto-collect real git context
+                const gitCtx = await (0, git_context_1.collectGitContext)();
                 const manager = new reentry_status_manager_1.ReentryStatusManager({ fileManager: new file_manager_1.FileManager() });
                 await manager.applyContext(cfg, {
                     trigger: 'postVersion',
                     command: 'versioning bump',
                     options,
-                    gitInfo: { branch: '', commit: '', author: '', timestamp: new Date().toISOString() },
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
                     versioningInfo: { versionType: type, oldVersion: undefined, newVersion: version }
                 });
+                // Auto-update phase and suggest next step
+                const current = await manager.loadOrInit(cfg);
+                const phase = (0, git_context_1.inferPhase)(gitCtx, version);
+                const nextStep = (0, git_context_1.suggestNextStep)(gitCtx);
+                const updated = {
+                    ...current,
+                    schemaVersion: '1.1',
+                    currentPhase: phase,
+                    nextSteps: [{ id: 'next', description: nextStep, priority: 1 }],
+                    version: version,
+                    versioning: {
+                        ...current.versioning,
+                        currentVersion: version,
+                        previousVersion: current.versioning.currentVersion,
+                        versionType: type,
+                    },
+                    lastUpdated: new Date().toISOString(),
+                };
+                await manager.updateStatus(cfg, () => updated);
                 await manager.syncAll(cfg);
+                console.log(`📋 Re-entry auto-updated: phase=${phase}, next="${nextStep}"`);
             }
             catch (error) {
                 console.warn('⚠️  reentry-status postVersion hook failed:', error instanceof Error ? error.message : String(error));
@@ -90,12 +117,19 @@ const extension = {
                     return;
                 if (reentryCfg.hooks?.postRelease !== true)
                     return;
+                // Auto-collect real git context
+                const gitCtx = await (0, git_context_1.collectGitContext)();
                 const manager = new reentry_status_manager_1.ReentryStatusManager({ fileManager: new file_manager_1.FileManager() });
                 await manager.applyContext(cfg, {
                     trigger: 'postRelease',
                     command: 'versioning release',
                     options,
-                    gitInfo: { branch: '', commit: '', author: '', timestamp: new Date().toISOString() },
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
                     versioningInfo: { newVersion: version }
                 });
                 await manager.syncAll(cfg);
@@ -209,7 +243,6 @@ const extension = {
             if (existingJson) {
                 const parsed = status_renderer_1.StatusRenderer.parseJson(existingJson);
                 if (migrate && parsed.schemaVersion === '1.0') {
-                    // Explicit migration: rewrite as 1.1 without changing semantics.
                     const migrated = {
                         ...parsed,
                         schemaVersion: '1.1',
@@ -257,6 +290,9 @@ const extension = {
             await fileManager.writeStatusFiles(cfg, initial);
             return { cfg, status: initial };
         };
+        // ─────────────────────────────────────────────
+        //  REENTRY COMMANDS
+        // ─────────────────────────────────────────────
         program
             .command('reentry')
             .description('Manage re-entry status (fast layer)')
@@ -291,6 +327,114 @@ const extension = {
             };
             await manager.updateStatus(cfg, () => updated);
             console.log('✅ Re-entry status updated');
+        }))
+            .addCommand(new commander_1.Command('update')
+            .description('Auto-fill re-entry status from last commit and current version (smart reentry)')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope')
+            .option('--phase <phase>', 'Override inferred phase')
+            .option('--next <text>', 'Override suggested next step')
+            .option('--dry-run', 'Show what would be updated without writing', false)
+            .action(async (options) => {
+            const { cfg, status } = await ensureReentryInitialized(options.config, false, options.project);
+            // Auto-collect git context
+            const gitCtx = await (0, git_context_1.collectGitContext)();
+            // Read current version from package.json
+            let currentVersion = status.versioning.currentVersion;
+            try {
+                const rootPkg = await fs.readJson('package.json');
+                currentVersion = rootPkg.version || currentVersion;
+            }
+            catch { /* keep existing */ }
+            // Infer phase or use override
+            const phase = options.phase || (0, git_context_1.inferPhase)(gitCtx, currentVersion);
+            // Suggest next step or use override
+            const nextStep = options.next || (0, git_context_1.suggestNextStep)(gitCtx);
+            const updated = {
+                ...status,
+                schemaVersion: '1.1',
+                version: currentVersion,
+                currentPhase: phase,
+                nextSteps: [{ id: 'next', description: nextStep, priority: 1 }],
+                context: {
+                    trigger: 'auto',
+                    command: 'versioning reentry update',
+                    gitInfo: {
+                        branch: gitCtx.branch,
+                        commit: gitCtx.commit,
+                        author: gitCtx.author,
+                        timestamp: gitCtx.timestamp,
+                    },
+                    versioningInfo: {
+                        newVersion: currentVersion,
+                    },
+                },
+                versioning: {
+                    ...status.versioning,
+                    currentVersion: currentVersion,
+                    previousVersion: status.versioning.currentVersion !== currentVersion
+                        ? status.versioning.currentVersion
+                        : status.versioning.previousVersion,
+                },
+                lastUpdated: new Date().toISOString(),
+                updatedBy: gitCtx.author || 'auto',
+            };
+            if (options.dryRun) {
+                console.log('\n📋 Re-entry Update Preview (dry-run)\n');
+                console.log(`  Branch:       ${gitCtx.branch}`);
+                console.log(`  Commit:       ${gitCtx.commit}`);
+                console.log(`  Message:      ${gitCtx.commitMessage}`);
+                console.log(`  Author:       ${gitCtx.author}`);
+                console.log(`  Version:      ${currentVersion}`);
+                console.log(`  Phase:        ${phase}`);
+                console.log(`  Next step:    ${nextStep}`);
+                console.log(`  Files changed: ${gitCtx.diffSummary.filesChanged} (+${gitCtx.diffSummary.insertions}/-${gitCtx.diffSummary.deletions})`);
+                console.log('\n  Use without --dry-run to apply.\n');
+                return;
+            }
+            await manager.updateStatus(cfg, () => updated);
+            console.log('\n📋 Re-entry Status Auto-Updated\n');
+            console.log(`  ├─ Branch:       ${gitCtx.branch}`);
+            console.log(`  ├─ Commit:       ${gitCtx.commit} — ${gitCtx.commitMessage}`);
+            console.log(`  ├─ Version:      ${currentVersion}`);
+            console.log(`  ├─ Phase:        ${phase}`);
+            console.log(`  ├─ Next step:    ${nextStep}`);
+            console.log(`  └─ Updated by:   ${gitCtx.author || 'auto'}\n`);
+            console.log('  🔜 Suggested workflow:');
+            console.log('     1. Review next step above');
+            console.log('     2. Work on the task');
+            console.log('     3. Commit & push');
+            console.log('     4. Run `versioning reentry update` again\n');
+        }))
+            .addCommand(new commander_1.Command('show')
+            .description('Show current re-entry status summary')
+            .option('-c, --config <file>', 'config file path', 'versioning.config.json')
+            .option('-p, --project <name>', 'project scope')
+            .option('--json', 'Output as JSON', false)
+            .action(async (options) => {
+            const { status } = await ensureReentryInitialized(options.config, false, options.project);
+            if (options.json) {
+                console.log(JSON.stringify(status, null, 2));
+                return;
+            }
+            const milestoneText = status.milestone
+                ? `${status.milestone.title} (${status.milestone.id})`
+                : '—';
+            const nextStep = status.nextSteps?.[0]?.description ?? '—';
+            const gitCommit = status.context?.gitInfo?.commit || '—';
+            const gitBranch = status.context?.gitInfo?.branch || '—';
+            console.log('\n┌───────────────────────────────────────────┐');
+            console.log('│         📋 Re-entry Status Summary         │');
+            console.log('├───────────────────────────────────────────┤');
+            console.log(`│  Version:     ${status.version.padEnd(28)}│`);
+            console.log(`│  Phase:       ${status.currentPhase.padEnd(28)}│`);
+            console.log(`│  Branch:      ${gitBranch.padEnd(28)}│`);
+            console.log(`│  Commit:      ${gitCommit.padEnd(28)}│`);
+            console.log(`│  Milestone:   ${milestoneText.padEnd(28).substring(0, 28)}│`);
+            console.log(`│  Next step:   ${nextStep.padEnd(28).substring(0, 28)}│`);
+            console.log(`│  Updated:     ${status.lastUpdated.substring(0, 19).padEnd(28)}│`);
+            console.log(`│  Roadmap:     ${status.roadmapFile.padEnd(28).substring(0, 28)}│`);
+            console.log('└───────────────────────────────────────────┘\n');
         }))
             .addCommand(new commander_1.Command('sync')
             .description('Ensure generated status files exist and are up to date (idempotent)')
@@ -384,6 +528,9 @@ const extension = {
             }
             console.log('✅ Re-entry sync complete');
         }));
+        // ─────────────────────────────────────────────
+        //  ROADMAP COMMANDS (expanded with project identification)
+        // ─────────────────────────────────────────────
         program
             .command('roadmap')
             .description('Manage roadmap/backlog (slow layer)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edcalderon/versioning",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "A comprehensive versioning and changelog management tool for monorepos",
   "main": "dist/index.js",
   "bin": {
@@ -78,4 +78,4 @@
     "url": "git+https://github.com/edcalderon/my-second-brain.git",
     "directory": "packages/versioning"
   }
-}
+}