specweave 0.16.5 → 0.16.11

package/dist/src/core/increment/limits.js

@@ -0,0 +1,224 @@
+/**
+ * Increment Limits
+ *
+ * Type-based limits for concurrent active increments.
+ * Part of increment 0007: Smart Status Management
+ */
+import { MetadataManager } from './metadata-manager';
+import { IncrementType, IncrementStatus, TYPE_LIMITS } from '../types/increment-metadata';
+/**
+ * Check if creating a new increment would exceed type-based limits
+ */
+export function checkIncrementLimits(type) {
+    // Get limit for this type
+    const limit = TYPE_LIMITS[type];
+    // Get active increments of this type (not paused, not completed, not abandoned)
+    const allIncrements = MetadataManager.getAll();
+    const activeOfType = allIncrements.filter(m => m.type === type && m.status === IncrementStatus.ACTIVE);
+    const current = activeOfType.length;
+    // If unlimited, no limit enforcement but still report current count
+    if (limit === null) {
+        return {
+            exceeded: false,
+            current,
+            limit: null,
+            severity: 'info'
+        };
+    }
+    const exceeded = current >= limit;
+    // Build result
+    const result = {
+        exceeded,
+        current,
+        limit,
+        severity: exceeded ? 'warning' : 'info',
+        activeIncrements: activeOfType
+    };
+    // Add warning message if exceeded
+    if (exceeded) {
+        result.warning = buildLimitWarning(type, current, limit, activeOfType);
+        result.suggestions = buildSuggestions(type, activeOfType);
+    }
+    return result;
+}
+/**
+ * Check all increment types and return warnings
+ */
+export function checkAllLimits() {
+    const results = {};
+    for (const type of Object.values(IncrementType)) {
+        results[type] = checkIncrementLimits(type);
+    }
+    return results;
+}
+/**
+ * Get context switching warning for starting a new increment
+ */
+export function getContextSwitchWarning(newType) {
+    const activeIncrements = MetadataManager.getActive();
+    const activeCount = activeIncrements.length;
+    // No warning if no active increments
+    if (activeCount === 0) {
+        return {
+            show: false,
+            productivityCost: '0%',
+            message: '',
+            options: []
+        };
+    }
+    // No warning for hotfixes (emergency work)
+    if (newType === IncrementType.HOTFIX || newType === IncrementType.BUG) {
+        return {
+            show: false,
+            productivityCost: '0%',
+            message: '',
+            options: []
+        };
+    }
+    // Calculate productivity cost
+    const productivityCost = calculateProductivityCost(activeCount);
+    // Build warning message
+    const message = buildContextSwitchMessage(activeCount, productivityCost, activeIncrements);
+    // Build options
+    const options = [
+        {
+            label: 'Continue current work',
+            value: 'continue',
+            description: 'Finish active increment(s) before starting new work (recommended)'
+        },
+        {
+            label: 'Pause current work',
+            value: 'pause',
+            description: 'Pause active increment(s) to focus on new work'
+        },
+        {
+            label: 'Work in parallel',
+            value: 'parallel',
+            description: `Start new increment (${productivityCost} productivity cost)`
+        }
+    ];
+    return {
+        show: true,
+        productivityCost,
+        message,
+        options
+    };
+}
+/**
+ * Build warning message for exceeded limit
+ */
+function buildLimitWarning(type, current, limit, activeIncrements) {
+    const typeLabel = formatTypeLabel(type);
+    const incrementList = activeIncrements
+        .map(m => `  • ${m.id}`)
+        .join('\n');
+    return `
+⚠️  You have ${current} active ${typeLabel} increment(s) (limit: ${limit})
+
+Active ${typeLabel} increments:
+${incrementList}
+
+Recommendation: Complete or pause one before starting another.
+Context switching reduces productivity by 20-40%.
+`.trim();
+}
+/**
+ * Build suggestions for resolving limit exceeded
+ */
+function buildSuggestions(type, activeIncrements) {
+    const suggestions = [];
+    // Suggest completing increments
+    suggestions.push(`Complete active increment: /done <id>`);
+    // Suggest pausing increments
+    suggestions.push(`Pause active increment: /pause <id>`);
+    // Show status
+    suggestions.push(`Check status: /status`);
+    // Type-specific suggestions
+    if (type === IncrementType.FEATURE) {
+        suggestions.push(`Reduce scope: Break large feature into smaller increments`);
+    }
+    else if (type === IncrementType.REFACTOR) {
+        suggestions.push(`Refactors need focus: Complete current refactor before starting new one`);
+    }
+    return suggestions;
+}
+/**
+ * Build context switching warning message
+ */
+function buildContextSwitchMessage(activeCount, productivityCost, activeIncrements) {
+    const incrementList = activeIncrements
+        .map(m => `  • ${m.id} [${m.type}]`)
+        .join('\n');
+    return `
+⚠️  You have ${activeCount} active increment(s)
+
+Active increments:
+${incrementList}
+
+Starting new work will reduce productivity by ${productivityCost} due to context switching.
+
+Research shows:
+• 2 concurrent tasks = 20% slower
+• 3+ concurrent tasks = 40% slower
+• Frequent switches = more bugs
+
+Recommended: Complete or pause active work first.
+`.trim();
+}
+/**
+ * Calculate productivity cost based on active increment count
+ */
+function calculateProductivityCost(activeCount) {
+    if (activeCount === 0)
+        return '0%';
+    if (activeCount === 1)
+        return '20%';
+    if (activeCount === 2)
+        return '30%';
+    return '40%';
+}
+/**
+ * Format type label for display
+ */
+function formatTypeLabel(type) {
+    switch (type) {
+        case IncrementType.HOTFIX: return 'hotfix';
+        case IncrementType.FEATURE: return 'feature';
+        case IncrementType.BUG: return 'bug';
+        case IncrementType.CHANGE_REQUEST: return 'change request';
+        case IncrementType.REFACTOR: return 'refactor';
+        case IncrementType.EXPERIMENT: return 'experiment';
+        default: return type;
+    }
+}
+/**
+ * Get summary of all limits
+ */
+export function getLimitsSummary() {
+    const results = checkAllLimits();
+    const lines = [];
+    lines.push('Increment Limits:');
+    lines.push('');
+    for (const [type, result] of Object.entries(results)) {
+        const typeLabel = formatTypeLabel(type);
+        const limitStr = result.limit === null ? 'unlimited' : result.limit.toString();
+        const status = result.exceeded ? '⚠️ ' : '✅';
+        lines.push(`${status} ${typeLabel}: ${result.current}/${limitStr} active`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Check if starting a new increment of this type would be allowed
+ * (considering limits)
+ */
+export function canStartIncrement(type) {
+    const check = checkIncrementLimits(type);
+    if (!check.exceeded) {
+        return { allowed: true };
+    }
+    return {
+        allowed: false,
+        reason: check.warning
+    };
+}
+//# sourceMappingURL=limits.js.map

package/dist/src/core/increment/limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.js","sourceRoot":"","sources":["../../../../src/core/increment/limits.ts"],"names":[],"mappings":"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"}

package/dist/src/core/increment/metadata-manager.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Metadata Manager
+ *
+ * Handles CRUD operations for increment metadata (status, type, timestamps).
+ * Part of increment 0007: Smart Status Management
+ */
+import { IncrementMetadata, IncrementMetadataExtended, IncrementStatus, IncrementType } from '../types/increment-metadata.js';
+/**
+ * Error thrown when metadata operations fail
+ */
+export declare class MetadataError extends Error {
+    incrementId: string;
+    cause?: Error;
+    constructor(message: string, incrementId: string, cause?: Error);
+}
+/**
+ * Metadata Manager
+ *
+ * Provides CRUD operations and queries for increment metadata
+ */
+export declare class MetadataManager {
+    /**
+     * Get metadata file path for increment
+     */
+    private static getMetadataPath;
+    /**
+     * Get increment directory path
+     */
+    private static getIncrementPath;
+    /**
+     * Check if metadata file exists
+     */
+    static exists(incrementId: string): boolean;
+    /**
+     * Read metadata from file
+     * Creates default metadata if file doesn't exist (lazy initialization)
+     */
+    static read(incrementId: string): IncrementMetadata;
+    /**
+     * Write metadata to file
+     * Uses atomic write (temp file → rename)
+     */
+    static write(incrementId: string, metadata: IncrementMetadata): void;
+    /**
+     * Delete metadata file
+     */
+    static delete(incrementId: string): void;
+    /**
+     * Update increment status
+     * Validates transition and updates timestamps
+     *
+     * **CRITICAL**: Also updates active increment state automatically!
+     */
+    static updateStatus(incrementId: string, newStatus: IncrementStatus, reason?: string): IncrementMetadata;
+    /**
+     * Update increment type
+     */
+    static updateType(incrementId: string, type: IncrementType): IncrementMetadata;
+    /**
+     * Touch increment (update lastActivity)
+     */
+    static touch(incrementId: string): IncrementMetadata;
+    /**
+     * Get all increments
+     */
+    static getAll(): IncrementMetadata[];
+    /**
+     * Get increments by status
+     */
+    static getByStatus(status: IncrementStatus): IncrementMetadata[];
+    /**
+     * Get active increments
+     */
+    static getActive(): IncrementMetadata[];
+    /**
+     * Get paused increments
+     */
+    static getPaused(): IncrementMetadata[];
+    /**
+     * Get completed increments
+     */
+    static getCompleted(): IncrementMetadata[];
+    /**
+     * Get abandoned increments
+     */
+    static getAbandoned(): IncrementMetadata[];
+    /**
+     * Get increments by type
+     */
+    static getByType(type: IncrementType): IncrementMetadata[];
+    /**
+     * Get stale increments (paused >7 days or active >30 days)
+     */
+    static getStale(): IncrementMetadata[];
+    /**
+     * Get increments that should be auto-abandoned (experiments inactive >14 days)
+     */
+    static getShouldAutoAbandon(): IncrementMetadata[];
+    /**
+     * Get extended metadata with computed fields (progress, age, etc.)
+     */
+    static getExtended(incrementId: string): IncrementMetadataExtended;
+    /**
+     * Validate metadata schema
+     */
+    static validate(metadata: IncrementMetadata): boolean;
+    /**
+     * Check if status transition is allowed
+     */
+    static canTransition(from: IncrementStatus, to: IncrementStatus): boolean;
+    /**
+     * Get human-readable status transition error message
+     */
+    static getTransitionError(from: IncrementStatus, to: IncrementStatus): string;
+}
+//# sourceMappingURL=metadata-manager.d.ts.map

package/dist/src/core/increment/metadata-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-manager.d.ts","sourceRoot":"","sources":["../../../../src/core/increment/metadata-manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EACL,iBAAiB,EACjB,yBAAyB,EACzB,eAAe,EACf,aAAa,EAKd,MAAM,gCAAgC,CAAC;AAGxC;;GAEG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACF,WAAW,EAAE,MAAM;IAAS,KAAK,CAAC,EAAE,KAAK;gBAAjE,OAAO,EAAE,MAAM,EAAS,WAAW,EAAE,MAAM,EAAS,KAAK,CAAC,EAAE,KAAK;CAI9E;AAED;;;;GAIG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAK9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAK/B;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAK3C;;;OAGG;IACH,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB;IAsCnD;;;OAGG;IACH,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IA8BpE;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAmBxC;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CACjB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,eAAe,EAC1B,MAAM,CAAC,EAAE,MAAM,GACd,iBAAiB;IAgDpB;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,iBAAiB;IAQ9E;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB;IAOpD;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,iBAAiB,EAAE;IAyBpC;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,iBAAiB,EAAE;IAIhE;;OAEG;IACH,MAAM,CAAC,SAAS,IAAI,iBAAiB,EAAE;IAIvC;;OAEG;IACH,MAAM,CAAC,SAAS,IAAI,iBAAiB,EAAE;IAIvC;;OAEG;IACH,MAAM,CAAC,YAAY,IAAI,iBAAiB,EAAE;IAI1C;;OAEG;IACH,MAAM,CAAC,YAAY,IAAI,iBAAiB,EAAE;IAI1C;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,iBAAiB,EAAE;IAI1D;;OAEG;IACH,MAAM,CAAC,QAAQ,IAAI,iBAAiB,EAAE;IAItC;;OAEG;IACH,MAAM,CAAC,oBAAoB,IAAI,iBAAiB,EAAE;IAIlD;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,yBAAyB;IAyClE;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO;IAwBrD;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,EAAE,eAAe,GAAG,OAAO;IAIzE;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,EAAE,eAAe,GAAG,MAAM;CAe9E"}

package/dist/src/core/increment/metadata-manager.js

@@ -0,0 +1,335 @@
+/**
+ * Metadata Manager
+ *
+ * Handles CRUD operations for increment metadata (status, type, timestamps).
+ * Part of increment 0007: Smart Status Management
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { IncrementStatus, IncrementType, createDefaultMetadata, isValidTransition, isStale, shouldAutoAbandon } from '../types/increment-metadata.js';
+import { ActiveIncrementManager } from './active-increment-manager.js';
+/**
+ * Error thrown when metadata operations fail
+ */
+export class MetadataError extends Error {
+    constructor(message, incrementId, cause) {
+        super(message);
+        this.incrementId = incrementId;
+        this.cause = cause;
+        this.name = 'MetadataError';
+    }
+}
+/**
+ * Metadata Manager
+ *
+ * Provides CRUD operations and queries for increment metadata
+ */
+export class MetadataManager {
+    /**
+     * Get metadata file path for increment
+     */
+    static getMetadataPath(incrementId) {
+        const specweavePath = path.join(process.cwd(), '.specweave');
+        return path.join(specweavePath, 'increments', incrementId, 'metadata.json');
+    }
+    /**
+     * Get increment directory path
+     */
+    static getIncrementPath(incrementId) {
+        const specweavePath = path.join(process.cwd(), '.specweave');
+        return path.join(specweavePath, 'increments', incrementId);
+    }
+    /**
+     * Check if metadata file exists
+     */
+    static exists(incrementId) {
+        const metadataPath = this.getMetadataPath(incrementId);
+        return fs.existsSync(metadataPath);
+    }
+    /**
+     * Read metadata from file
+     * Creates default metadata if file doesn't exist (lazy initialization)
+     */
+    static read(incrementId) {
+        const metadataPath = this.getMetadataPath(incrementId);
+        // Lazy initialization: Create metadata if doesn't exist
+        if (!fs.existsSync(metadataPath)) {
+            // Check if increment folder exists
+            const incrementPath = this.getIncrementPath(incrementId);
+            if (!fs.existsSync(incrementPath)) {
+                throw new MetadataError(`Increment not found: ${incrementId}`, incrementId);
+            }
+            // Create default metadata
+            const defaultMetadata = createDefaultMetadata(incrementId);
+            this.write(incrementId, defaultMetadata);
+            return defaultMetadata;
+        }
+        try {
+            const content = fs.readFileSync(metadataPath, 'utf-8');
+            const metadata = JSON.parse(content);
+            // Validate schema
+            this.validate(metadata);
+            return metadata;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new MetadataError(`Failed to read metadata for ${incrementId}: ${errorMessage}`, incrementId, error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Write metadata to file
+     * Uses atomic write (temp file → rename)
+     */
+    static write(incrementId, metadata) {
+        const metadataPath = this.getMetadataPath(incrementId);
+        const incrementPath = this.getIncrementPath(incrementId);
+        // Ensure increment directory exists
+        if (!fs.existsSync(incrementPath)) {
+            throw new MetadataError(`Increment directory not found: ${incrementId}`, incrementId);
+        }
+        try {
+            // Validate before writing
+            this.validate(metadata);
+            // Atomic write: temp file → rename
+            const tempPath = `${metadataPath}.tmp`;
+            fs.writeFileSync(tempPath, JSON.stringify(metadata, null, 2), 'utf-8');
+            fs.renameSync(tempPath, metadataPath);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new MetadataError(`Failed to write metadata for ${incrementId}: ${errorMessage}`, incrementId, error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Delete metadata file
+     */
+    static delete(incrementId) {
+        const metadataPath = this.getMetadataPath(incrementId);
+        if (!fs.existsSync(metadataPath)) {
+            return; // Already deleted
+        }
+        try {
+            fs.unlinkSync(metadataPath);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new MetadataError(`Failed to delete metadata for ${incrementId}: ${errorMessage}`, incrementId, error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Update increment status
+     * Validates transition and updates timestamps
+     *
+     * **CRITICAL**: Also updates active increment state automatically!
+     */
+    static updateStatus(incrementId, newStatus, reason) {
+        const metadata = this.read(incrementId);
+        // Validate transition
+        if (!isValidTransition(metadata.status, newStatus)) {
+            throw new MetadataError(`Invalid status transition: ${metadata.status} → ${newStatus}`, incrementId);
+        }
+        // Update status
+        metadata.status = newStatus;
+        metadata.lastActivity = new Date().toISOString();
+        // Update status-specific fields
+        if (newStatus === IncrementStatus.PAUSED) {
+            metadata.pausedReason = reason || 'No reason provided';
+            metadata.pausedAt = new Date().toISOString();
+        }
+        else if (newStatus === IncrementStatus.ACTIVE) {
+            // Clear paused fields when resuming
+            metadata.pausedReason = undefined;
+            metadata.pausedAt = undefined;
+        }
+        else if (newStatus === IncrementStatus.ABANDONED) {
+            metadata.abandonedReason = reason || 'No reason provided';
+            metadata.abandonedAt = new Date().toISOString();
+        }
+        this.write(incrementId, metadata);
+        // **CRITICAL**: Update active increment state
+        const activeManager = new ActiveIncrementManager();
+        if (newStatus === IncrementStatus.ACTIVE) {
+            // Increment became active → set as active
+            activeManager.setActive(incrementId);
+        }
+        else if (newStatus === IncrementStatus.COMPLETED ||
+            newStatus === IncrementStatus.PAUSED ||
+            newStatus === IncrementStatus.ABANDONED) {
+            // Increment no longer active → smart update (find next active or clear)
+            activeManager.smartUpdate();
+        }
+        return metadata;
+    }
+    /**
+     * Update increment type
+     */
+    static updateType(incrementId, type) {
+        const metadata = this.read(incrementId);
+        metadata.type = type;
+        metadata.lastActivity = new Date().toISOString();
+        this.write(incrementId, metadata);
+        return metadata;
+    }
+    /**
+     * Touch increment (update lastActivity)
+     */
+    static touch(incrementId) {
+        const metadata = this.read(incrementId);
+        metadata.lastActivity = new Date().toISOString();
+        this.write(incrementId, metadata);
+        return metadata;
+    }
+    /**
+     * Get all increments
+     */
+    static getAll() {
+        const incrementsPath = path.join(process.cwd(), '.specweave', 'increments');
+        if (!fs.existsSync(incrementsPath)) {
+            return [];
+        }
+        const incrementFolders = fs.readdirSync(incrementsPath)
+            .filter(name => {
+            const folderPath = path.join(incrementsPath, name);
+            return fs.statSync(folderPath).isDirectory() && !name.startsWith('_');
+        });
+        return incrementFolders
+            .map(folder => {
+            try {
+                return this.read(folder);
+            }
+            catch (error) {
+                // Skip increments with invalid/missing metadata
+                return null;
+            }
+        })
+            .filter((m) => m !== null);
+    }
+    /**
+     * Get increments by status
+     */
+    static getByStatus(status) {
+        return this.getAll().filter(m => m.status === status);
+    }
+    /**
+     * Get active increments
+     */
+    static getActive() {
+        return this.getByStatus(IncrementStatus.ACTIVE);
+    }
+    /**
+     * Get paused increments
+     */
+    static getPaused() {
+        return this.getByStatus(IncrementStatus.PAUSED);
+    }
+    /**
+     * Get completed increments
+     */
+    static getCompleted() {
+        return this.getByStatus(IncrementStatus.COMPLETED);
+    }
+    /**
+     * Get abandoned increments
+     */
+    static getAbandoned() {
+        return this.getByStatus(IncrementStatus.ABANDONED);
+    }
+    /**
+     * Get increments by type
+     */
+    static getByType(type) {
+        return this.getAll().filter(m => m.type === type);
+    }
+    /**
+     * Get stale increments (paused >7 days or active >30 days)
+     */
+    static getStale() {
+        return this.getAll().filter(m => isStale(m));
+    }
+    /**
+     * Get increments that should be auto-abandoned (experiments inactive >14 days)
+     */
+    static getShouldAutoAbandon() {
+        return this.getAll().filter(m => shouldAutoAbandon(m));
+    }
+    /**
+     * Get extended metadata with computed fields (progress, age, etc.)
+     */
+    static getExtended(incrementId) {
+        const metadata = this.read(incrementId);
+        const extended = { ...metadata };
+        // Calculate progress from tasks.md
+        try {
+            const tasksPath = path.join(this.getIncrementPath(incrementId), 'tasks.md');
+            if (fs.existsSync(tasksPath)) {
+                const tasksContent = fs.readFileSync(tasksPath, 'utf-8');
+                // Count completed tasks: [x] or [X]
+                const completedMatches = tasksContent.match(/\[x\]/gi);
+                extended.completedTasks = completedMatches ? completedMatches.length : 0;
+                // Count total tasks: [ ] or [x]
+                const totalMatches = tasksContent.match(/\[ \]|\[x\]/gi);
+                extended.totalTasks = totalMatches ? totalMatches.length : 0;
+                // Calculate progress percentage
+                if (extended.totalTasks > 0) {
+                    extended.progress = Math.round((extended.completedTasks / extended.totalTasks) * 100);
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors reading tasks.md
+        }
+        // Calculate age in days
+        const now = new Date();
+        const createdDate = new Date(metadata.created);
+        extended.ageInDays = Math.floor((now.getTime() - createdDate.getTime()) / (1000 * 60 * 60 * 24));
+        // Calculate days paused
+        if (metadata.status === IncrementStatus.PAUSED && metadata.pausedAt) {
+            const pausedDate = new Date(metadata.pausedAt);
+            extended.daysPaused = Math.floor((now.getTime() - pausedDate.getTime()) / (1000 * 60 * 60 * 24));
+        }
+        return extended;
+    }
+    /**
+     * Validate metadata schema
+     */
+    static validate(metadata) {
+        if (!metadata.id) {
+            throw new Error('Metadata missing required field: id');
+        }
+        if (!metadata.status || !Object.values(IncrementStatus).includes(metadata.status)) {
+            throw new Error(`Invalid status: ${metadata.status}`);
+        }
+        if (!metadata.type || !Object.values(IncrementType).includes(metadata.type)) {
+            throw new Error(`Invalid type: ${metadata.type}`);
+        }
+        if (!metadata.created) {
+            throw new Error('Metadata missing required field: created');
+        }
+        if (!metadata.lastActivity) {
+            throw new Error('Metadata missing required field: lastActivity');
+        }
+        return true;
+    }
+    /**
+     * Check if status transition is allowed
+     */
+    static canTransition(from, to) {
+        return isValidTransition(from, to);
+    }
+    /**
+     * Get human-readable status transition error message
+     */
+    static getTransitionError(from, to) {
+        if (from === IncrementStatus.COMPLETED) {
+            return `Cannot transition from completed state. Increment is already complete.`;
+        }
+        if (to === IncrementStatus.PAUSED && from === IncrementStatus.ABANDONED) {
+            return `Cannot pause an abandoned increment. Resume it first with /resume.`;
+        }
+        if (to === IncrementStatus.COMPLETED && from === IncrementStatus.ABANDONED) {
+            return `Cannot complete an abandoned increment. Resume it first with /resume.`;
+        }
+        return `Invalid transition: ${from} → ${to}`;
+    }
+}
+//# sourceMappingURL=metadata-manager.js.map