newo 1.7.2 → 1.8.0

package/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.8.0] - 2025-09-15
+
+### Added
+- **Complete Metadata Change Tracking**: Comprehensive metadata.yaml file synchronization
+  - All metadata.yaml files now tracked with hash-based change detection
+  - Status command shows detailed metadata changes (title, runner_type, model)
+  - Push command automatically updates skills when metadata changes
+  - flows.yaml automatically regenerated when metadata changes detected
+  - Preserves flows.yaml format consistency with backup/comparison system
+
+### Enhanced
+- **Comprehensive File Synchronization**: All NEWO workspace files fully tracked
+  - Skills: .guidance and .jinja script files with hash tracking ✓
+  - Metadata: metadata.yaml files with skill updates + flows.yaml regeneration ✓
+  - Attributes: attributes.yaml with diff-based sync for 233 customer attributes ✓
+  - Flows: flows.yaml with automatic regeneration and format preservation ✓
+  - Multi-customer: All file types synchronized across multiple customer workspaces ✓
+
+### Technical
+- **flows.yaml Regeneration**: Automatic regeneration pipeline when metadata changes
+  - Creates backup before regeneration for format comparison
+  - Re-fetches project data to ensure accuracy
+  - Updates hash tracking for regenerated flows.yaml
+  - Maintains consistent YAML format structure
+
+## [1.7.3] - 2025-09-15
+
+### Added
+- **Complete Attributes Change Tracking**: Full hash-based change detection for customer attributes
+  - Attributes.yaml files now included in hash tracking during pull operations
+  - Status command detects and reports modifications to attributes.yaml files
+  - Push command detects and handles attributes changes with proper synchronization
+  - Comprehensive workflow: modify → status shows change → push applies change → status shows clean
+
+### Enhanced
+- **File Synchronization Scope**: Extended to cover all file types in NEWO workspace
+  - Skills: .guidance and .jinja files with full hash tracking ✓
+  - Attributes: customer attributes.yaml with change detection ✓
+  - Metadata: flows.yaml and metadata.yaml files tracked ✓
+  - Multi-customer: all file types synchronized across multiple customers ✓
+
 ## [1.7.2] - 2025-09-15
 
 ### Fixed

package/dist/fsutil.d.ts

@@ -11,6 +11,7 @@ export declare function projectDir(customerIdn: string, projectIdn: string): str
 export declare function flowsYamlPath(customerIdn: string): string;
 export declare function customerAttributesPath(customerIdn: string): string;
 export declare function customerAttributesMapPath(customerIdn: string): string;
+export declare function customerAttributesBackupPath(customerIdn: string): string;
 export declare function skillPath(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string, runnerType?: RunnerType): string;
 export declare function skillFolderPath(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string): string;
 export declare function skillScriptPath(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string, runnerType?: RunnerType): string;

package/dist/fsutil.js

@@ -34,6 +34,9 @@ export function customerAttributesPath(customerIdn) {
 export function customerAttributesMapPath(customerIdn) {
     return path.join(customerStateDir(customerIdn), 'attributes-map.json');
 }
+export function customerAttributesBackupPath(customerIdn) {
+    return path.join(customerStateDir(customerIdn), 'attributes-backup.yaml');
+}
 // Legacy skill path - direct file
 export function skillPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType = 'guidance') {
     const extension = runnerType === 'nsl' ? '.jinja' : '.guidance';

package/dist/sync.js

@@ -1,5 +1,5 @@
-import { listProjects, listAgents, listFlowSkills, updateSkill, listFlowEvents, listFlowStates, getProjectMeta, getCustomerAttributes } from './api.js';
-import { ensureState, skillPath, skillScriptPath, writeFileSafe, readIfExists, mapPath, projectMetadataPath, agentMetadataPath, flowMetadataPath, skillMetadataPath, flowsYamlPath, customerAttributesPath, customerAttributesMapPath } from './fsutil.js';
+import { listProjects, listAgents, listFlowSkills, updateSkill, listFlowEvents, listFlowStates, getProjectMeta, getCustomerAttributes, updateCustomerAttribute } from './api.js';
+import { ensureState, skillPath, skillScriptPath, writeFileSafe, readIfExists, mapPath, projectMetadataPath, agentMetadataPath, flowMetadataPath, skillMetadataPath, flowsYamlPath, customerAttributesPath, customerAttributesMapPath, customerAttributesBackupPath } from './fsutil.js';
 import fs from 'fs-extra';
 import { sha256, loadHashes, saveHashes } from './hash.js';
 import yaml from 'js-yaml';
@@ -76,12 +76,14 @@ export async function saveCustomerAttributes(client, customer, verbose = false)
         yamlContent = yamlContent.replace(/__ENUM_PLACEHOLDER_(\w+)__/g, '!enum "AttributeValueTypes.$1"');
         // Fix JSON string formatting to match reference (remove escape characters)
         yamlContent = yamlContent.replace(/\\"/g, '"');
-        // Save both files
+        // Save all files: attributes.yaml, ID mapping, and backup for diff tracking
         await writeFileSafe(customerAttributesPath(customer.idn), yamlContent);
         await writeFileSafe(customerAttributesMapPath(customer.idn), JSON.stringify(idMapping, null, 2));
+        await writeFileSafe(customerAttributesBackupPath(customer.idn), yamlContent);
         if (verbose) {
             console.log(`✓ Saved customer attributes to ${customerAttributesPath(customer.idn)}`);
             console.log(`✓ Saved attribute ID mapping to ${customerAttributesMapPath(customer.idn)}`);
+            console.log(`✓ Created attributes backup for diff tracking`);
         }
     }
     catch (error) {
@@ -215,21 +217,43 @@ export async function pullAll(client, customer, projectId = null, verbose = fals
                     const newPath = skillScriptPath(customer.idn, projectMeta.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     const content = await fs.readFile(newPath, 'utf8');
                     hashes[newPath] = sha256(content);
+                    // Track skill metadata.yaml file
+                    const metadataPath = skillMetadataPath(customer.idn, projectMeta.idn, agentIdn, flowIdn, skillIdn);
+                    if (await fs.pathExists(metadataPath)) {
+                        const metadataContent = await fs.readFile(metadataPath, 'utf8');
+                        hashes[metadataPath] = sha256(metadataContent);
+                    }
                     // Also track legacy path for backwards compatibility during transition
                     const legacyPath = skillPath(customer.idn, projectMeta.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     hashes[legacyPath] = sha256(content);
                 }
             }
         }
-        await saveHashes(hashes, customer.idn);
-        // Save customer attributes
+        // Save customer attributes before hash tracking
         try {
             await saveCustomerAttributes(client, customer, verbose);
+            // Add attributes.yaml to hash tracking
+            const attributesFile = customerAttributesPath(customer.idn);
+            if (await fs.pathExists(attributesFile)) {
+                const attributesContent = await fs.readFile(attributesFile, 'utf8');
+                hashes[attributesFile] = sha256(attributesContent);
+                if (verbose)
+                    console.log(`✓ Added attributes.yaml to hash tracking`);
+            }
+            // Add flows.yaml to hash tracking
+            const flowsFile = flowsYamlPath(customer.idn);
+            if (await fs.pathExists(flowsFile)) {
+                const flowsContent = await fs.readFile(flowsFile, 'utf8');
+                hashes[flowsFile] = sha256(flowsContent);
+                if (verbose)
+                    console.log(`✓ Added flows.yaml to hash tracking`);
+            }
         }
         catch (error) {
             console.error(`❌ Failed to save customer attributes for ${customer.idn}:`, error);
             // Don't throw - continue with the rest of the process
         }
+        await saveHashes(hashes, customer.idn);
         return;
     }
     // Multi-project mode
@@ -253,6 +277,12 @@ export async function pullAll(client, customer, projectId = null, verbose = fals
                     const newPath = skillScriptPath(customer.idn, project.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     const content = await fs.readFile(newPath, 'utf8');
                     allHashes[newPath] = sha256(content);
+                    // Track skill metadata.yaml file
+                    const metadataPath = skillMetadataPath(customer.idn, project.idn, agentIdn, flowIdn, skillIdn);
+                    if (await fs.pathExists(metadataPath)) {
+                        const metadataContent = await fs.readFile(metadataPath, 'utf8');
+                        allHashes[metadataPath] = sha256(metadataContent);
+                    }
                     // Also track legacy path for backwards compatibility during transition
                     const legacyPath = skillPath(customer.idn, project.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
                     allHashes[legacyPath] = sha256(content);
@@ -261,15 +291,31 @@ export async function pullAll(client, customer, projectId = null, verbose = fals
         }
     }
     await fs.writeJson(mapPath(customer.idn), idMap, { spaces: 2 });
-    await saveHashes(allHashes, customer.idn);
-    // Save customer attributes
+    // Save customer attributes before hash tracking
     try {
         await saveCustomerAttributes(client, customer, verbose);
+        // Add attributes.yaml to hash tracking
+        const attributesFile = customerAttributesPath(customer.idn);
+        if (await fs.pathExists(attributesFile)) {
+            const attributesContent = await fs.readFile(attributesFile, 'utf8');
+            allHashes[attributesFile] = sha256(attributesContent);
+            if (verbose)
+                console.log(`✓ Added attributes.yaml to hash tracking`);
+        }
+        // Add flows.yaml to hash tracking
+        const flowsFile = flowsYamlPath(customer.idn);
+        if (await fs.pathExists(flowsFile)) {
+            const flowsContent = await fs.readFile(flowsFile, 'utf8');
+            allHashes[flowsFile] = sha256(flowsContent);
+            if (verbose)
+                console.log(`✓ Added flows.yaml to hash tracking`);
+        }
     }
     catch (error) {
         console.error(`❌ Failed to save customer attributes for ${customer.idn}:`, error);
         // Don't throw - continue with the rest of the process
     }
+    await saveHashes(allHashes, customer.idn);
 }
 export async function pushChanged(client, customer, verbose = false) {
     await ensureState(customer.idn);
@@ -287,6 +333,7 @@ export async function pushChanged(client, customer, verbose = false) {
         console.log('🔄 Scanning for changes...');
     let pushed = 0;
     let scanned = 0;
+    let metadataChanged = false;
     // Handle both old single-project format and new multi-project format with type guards
     const projects = isProjectMap(idMapData) && idMapData.projects
         ? idMapData.projects
@@ -387,24 +434,178 @@ export async function pushChanged(client, customer, verbose = false) {
             }
         }
     }
+    // Check for metadata-only changes (when metadata changed but script didn't)
+    try {
+        for (const [projectIdn, projectData] of Object.entries(projects)) {
+            for (const [agentIdn, agentObj] of Object.entries(projectData.agents)) {
+                for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
+                    for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
+                        const metadataPath = projectIdn ?
+                            skillMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn) :
+                            skillMetadataPath(customer.idn, '', agentIdn, flowIdn, skillIdn);
+                        if (await fs.pathExists(metadataPath)) {
+                            const metadataContent = await fs.readFile(metadataPath, 'utf8');
+                            const h = sha256(metadataContent);
+                            const oldHash = oldHashes[metadataPath];
+                            if (oldHash !== h) {
+                                if (verbose)
+                                    console.log(`🔄 Metadata-only change detected for ${skillIdn}, updating skill...`);
+                                try {
+                                    // Load updated metadata
+                                    const updatedMetadata = yaml.load(metadataContent);
+                                    // Get current script content
+                                    const scriptPath = projectIdn ?
+                                        skillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type) :
+                                        skillScriptPath(customer.idn, '', agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+                                    let scriptContent = '';
+                                    if (await fs.pathExists(scriptPath)) {
+                                        scriptContent = await fs.readFile(scriptPath, 'utf8');
+                                    }
+                                    // Create skill object with updated metadata
+                                    const skillObject = {
+                                        id: updatedMetadata.id,
+                                        title: updatedMetadata.title,
+                                        idn: updatedMetadata.idn,
+                                        prompt_script: scriptContent,
+                                        runner_type: updatedMetadata.runner_type,
+                                        model: updatedMetadata.model,
+                                        parameters: updatedMetadata.parameters,
+                                        path: updatedMetadata.path || undefined
+                                    };
+                                    await updateSkill(client, skillObject);
+                                    console.log(`↑ Pushed metadata update for skill: ${skillIdn} (${updatedMetadata.title})`);
+                                    newHashes[metadataPath] = h;
+                                    pushed++;
+                                    metadataChanged = true;
+                                }
+                                catch (error) {
+                                    console.error(`❌ Failed to push metadata for ${skillIdn}: ${error instanceof Error ? error.message : String(error)}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (verbose)
+            console.log(`⚠️  Metadata push check failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
     if (verbose)
         console.log(`🔄 Scanned ${scanned} files, found ${pushed} changes`);
-    // Check for attributes changes and push if needed
+    // Check for attributes changes and push specific changed attributes only
     try {
         const attributesFile = customerAttributesPath(customer.idn);
         const attributesMapFile = customerAttributesMapPath(customer.idn);
+        const attributesBackupFile = customerAttributesBackupPath(customer.idn);
         if (await fs.pathExists(attributesFile) && await fs.pathExists(attributesMapFile)) {
             if (verbose)
                 console.log('🔍 Checking customer attributes for changes...');
-            // Check file modification time for change detection instead of YAML parsing
-            const attributesStats = await fs.stat(attributesFile);
-            const idMapping = await fs.readJson(attributesMapFile);
-            // Count attributes by ID mapping instead of parsing YAML (avoids enum parsing issues)
-            const attributeCount = Object.keys(idMapping).length;
-            if (verbose) {
-                console.log(`📊 Found ${attributeCount} attributes ready for push operations`);
-                console.log(`📅 Attributes file last modified: ${attributesStats.mtime.toISOString()}`);
-                // TODO: Implement change detection by comparing with last push timestamp
+            const currentContent = await fs.readFile(attributesFile, 'utf8');
+            // Check if backup exists for diff comparison
+            if (await fs.pathExists(attributesBackupFile)) {
+                const backupContent = await fs.readFile(attributesBackupFile, 'utf8');
+                if (currentContent !== backupContent) {
+                    if (verbose)
+                        console.log(`🔄 Attributes file changed, analyzing differences...`);
+                    try {
+                        // Load ID mapping for push operations
+                        const idMapping = await fs.readJson(attributesMapFile);
+                        // Parse both versions to find changed attributes
+                        const parseYaml = (content) => {
+                            let yamlContent = content.replace(/!enum "([^"]+)"/g, '"$1"');
+                            return yaml.load(yamlContent);
+                        };
+                        const currentData = parseYaml(currentContent);
+                        const backupData = parseYaml(backupContent);
+                        if (currentData?.attributes && backupData?.attributes) {
+                            // Create maps for comparison
+                            const currentAttrs = new Map(currentData.attributes.map(attr => [attr.idn, attr]));
+                            const backupAttrs = new Map(backupData.attributes.map(attr => [attr.idn, attr]));
+                            let attributesPushed = 0;
+                            // Find changed attributes
+                            for (const [idn, currentAttr] of currentAttrs) {
+                                const backupAttr = backupAttrs.get(idn);
+                                // Check if attribute changed (deep comparison of key fields)
+                                const hasChanged = !backupAttr ||
+                                    currentAttr.value !== backupAttr.value ||
+                                    currentAttr.title !== backupAttr.title ||
+                                    currentAttr.description !== backupAttr.description ||
+                                    currentAttr.group !== backupAttr.group ||
+                                    currentAttr.is_hidden !== backupAttr.is_hidden;
+                                if (hasChanged) {
+                                    const attributeId = idMapping[idn];
+                                    if (!attributeId) {
+                                        if (verbose)
+                                            console.log(`⚠️  Skipping ${idn} - no ID mapping`);
+                                        continue;
+                                    }
+                                    // Create attribute object for push
+                                    const attributeToUpdate = {
+                                        id: attributeId,
+                                        idn: currentAttr.idn,
+                                        value: currentAttr.value,
+                                        title: currentAttr.title || "",
+                                        description: currentAttr.description || "",
+                                        group: currentAttr.group || "",
+                                        is_hidden: currentAttr.is_hidden,
+                                        possible_values: currentAttr.possible_values || [],
+                                        value_type: currentAttr.value_type?.replace(/^"?AttributeValueTypes\.(.+)"?$/, '$1') || "string"
+                                    };
+                                    await updateCustomerAttribute(client, attributeToUpdate);
+                                    attributesPushed++;
+                                    if (verbose) {
+                                        console.log(`  ✓ Pushed changed attribute: ${idn}`);
+                                        console.log(`    Old value: ${backupAttr?.value || 'N/A'}`);
+                                        console.log(`    New value: ${currentAttr.value}`);
+                                    }
+                                }
+                            }
+                            if (attributesPushed > 0) {
+                                console.log(`↑ Pushed ${attributesPushed} changed customer attributes to NEWO API`);
+                                // Show summary of what was pushed
+                                console.log(`  📊 Pushed attributes:`);
+                                for (const [idn, currentAttr] of currentAttrs) {
+                                    const backupAttr = backupAttrs.get(idn);
+                                    const hasChanged = !backupAttr ||
+                                        currentAttr.value !== backupAttr.value ||
+                                        currentAttr.title !== backupAttr.title ||
+                                        currentAttr.description !== backupAttr.description ||
+                                        currentAttr.group !== backupAttr.group ||
+                                        currentAttr.is_hidden !== backupAttr.is_hidden;
+                                    if (hasChanged) {
+                                        console.log(`    • ${idn}: ${currentAttr.title || 'No title'}`);
+                                        console.log(`      Value: ${currentAttr.value}`);
+                                    }
+                                }
+                                // Update backup file after successful push
+                                await fs.writeFile(attributesBackupFile, currentContent, 'utf8');
+                                newHashes[attributesFile] = sha256(currentContent);
+                                pushed++;
+                            }
+                            else if (verbose) {
+                                console.log(`  ✓ No attribute value changes detected`);
+                            }
+                        }
+                        else {
+                            console.log(`⚠️  Failed to parse attributes for comparison`);
+                        }
+                    }
+                    catch (error) {
+                        console.error(`❌ Failed to push changed attributes: ${error instanceof Error ? error.message : String(error)}`);
+                        // Don't update hash/backup on failure so it will retry next time
+                    }
+                }
+                else if (verbose) {
+                    console.log(`  ✓ No attributes file changes`);
+                }
+            }
+            else {
+                // No backup exists, create initial backup
+                await fs.writeFile(attributesBackupFile, currentContent, 'utf8');
+                if (verbose)
+                    console.log(`✓ Created initial attributes backup for diff tracking`);
             }
         }
         else if (verbose) {
@@ -415,6 +616,47 @@ export async function pushChanged(client, customer, verbose = false) {
         if (verbose)
             console.log(`⚠️  Attributes push check failed: ${error instanceof Error ? error.message : String(error)}`);
     }
+    // Regenerate flows.yaml if metadata changed
+    if (metadataChanged) {
+        try {
+            if (verbose)
+                console.log('🔄 Metadata changed, regenerating flows.yaml...');
+            // Create backup of current flows.yaml for format comparison
+            const flowsFile = flowsYamlPath(customer.idn);
+            let flowsBackup = '';
+            if (await fs.pathExists(flowsFile)) {
+                flowsBackup = await fs.readFile(flowsFile, 'utf8');
+                const backupPath = `${flowsFile}.backup`;
+                await fs.writeFile(backupPath, flowsBackup, 'utf8');
+                if (verbose)
+                    console.log(`✓ Created flows.yaml backup at ${backupPath}`);
+            }
+            // Re-fetch agents for flows.yaml regeneration
+            const agentsForFlows = [];
+            for (const projectData of Object.values(projects)) {
+                const projectAgents = await listAgents(client, projectData.projectId);
+                agentsForFlows.push(...projectAgents);
+            }
+            // Regenerate flows.yaml
+            await generateFlowsYaml(client, customer, agentsForFlows, verbose);
+            // Update flows.yaml hash
+            if (await fs.pathExists(flowsFile)) {
+                const newFlowsContent = await fs.readFile(flowsFile, 'utf8');
+                newHashes[flowsFile] = sha256(newFlowsContent);
+                // Compare format with backup
+                if (flowsBackup) {
+                    const sizeDiff = newFlowsContent.length - flowsBackup.length;
+                    if (verbose) {
+                        console.log(`✓ Regenerated flows.yaml (size change: ${sizeDiff > 0 ? '+' : ''}${sizeDiff} chars)`);
+                    }
+                }
+            }
+            console.log('↑ Regenerated flows.yaml due to metadata changes');
+        }
+        catch (error) {
+            console.error(`❌ Failed to regenerate flows.yaml: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     await saveHashes(newHashes, customer.idn);
     console.log(pushed ? `✅ Push complete. ${pushed} file(s) updated.` : '✅ Nothing to push.');
 }
@@ -485,6 +727,48 @@ export async function status(customer, verbose = false) {
                         console.log(`      ✓ Unchanged: ${currentPath}`);
                     }
                 }
+                // Check metadata.yaml files for changes (after skill files)
+                for (const [skillIdn] of Object.entries(flowObj.skills)) {
+                    const metadataPath = projectIdn ?
+                        skillMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn) :
+                        skillMetadataPath(customer.idn, '', agentIdn, flowIdn, skillIdn);
+                    if (await fs.pathExists(metadataPath)) {
+                        const metadataContent = await fs.readFile(metadataPath, 'utf8');
+                        const h = sha256(metadataContent);
+                        const oldHash = hashes[metadataPath];
+                        if (verbose) {
+                            console.log(`      📄 ${metadataPath}`);
+                            console.log(`        Old hash: ${oldHash || 'none'}`);
+                            console.log(`        New hash: ${h}`);
+                        }
+                        if (oldHash !== h) {
+                            console.log(`M  ${metadataPath}`);
+                            dirty++;
+                            // Show which metadata fields changed
+                            try {
+                                const newMetadata = yaml.load(metadataContent);
+                                console.log(`      📊 Metadata changed for skill: ${skillIdn}`);
+                                if (newMetadata?.title) {
+                                    console.log(`        • Title: ${newMetadata.title}`);
+                                }
+                                if (newMetadata?.runner_type) {
+                                    console.log(`        • Runner: ${newMetadata.runner_type}`);
+                                }
+                                if (newMetadata?.model) {
+                                    console.log(`        • Model: ${newMetadata.model.provider_idn}/${newMetadata.model.model_idn}`);
+                                }
+                            }
+                            catch (e) {
+                                // Fallback to simple message
+                                if (verbose)
+                                    console.log(`      🔄 Modified: metadata.yaml`);
+                            }
+                        }
+                        else if (verbose) {
+                            console.log(`      ✓ Unchanged: ${metadataPath}`);
+                        }
+                    }
+                }
             }
         }
     }
@@ -492,16 +776,71 @@ export async function status(customer, verbose = false) {
     try {
         const attributesFile = customerAttributesPath(customer.idn);
         if (await fs.pathExists(attributesFile)) {
-            const attributesStats = await fs.stat(attributesFile);
-            const attributesPath = `${customer.idn}/attributes.yaml`;
+            const content = await fs.readFile(attributesFile, 'utf8');
+            const h = sha256(content);
+            const oldHash = hashes[attributesFile];
             if (verbose) {
-                console.log(`📄 ${attributesPath}`);
-                console.log(`  📅 Last modified: ${attributesStats.mtime.toISOString()}`);
-                console.log(`  📊 Size: ${(attributesStats.size / 1024).toFixed(1)}KB`);
+                console.log(`📄 ${attributesFile}`);
+                console.log(`  Old hash: ${oldHash || 'none'}`);
+                console.log(`  New hash: ${h}`);
+            }
+            if (oldHash !== h) {
+                console.log(`M  ${attributesFile}`);
+                dirty++;
+                // Show which attributes changed by comparing with backup
+                try {
+                    const attributesBackupFile = customerAttributesBackupPath(customer.idn);
+                    if (await fs.pathExists(attributesBackupFile)) {
+                        const backupContent = await fs.readFile(attributesBackupFile, 'utf8');
+                        const parseYaml = (content) => {
+                            let yamlContent = content.replace(/!enum "([^"]+)"/g, '"$1"');
+                            return yaml.load(yamlContent);
+                        };
+                        const currentData = parseYaml(content);
+                        const backupData = parseYaml(backupContent);
+                        if (currentData?.attributes && backupData?.attributes) {
+                            const currentAttrs = new Map(currentData.attributes.map(attr => [attr.idn, attr]));
+                            const backupAttrs = new Map(backupData.attributes.map(attr => [attr.idn, attr]));
+                            const changedAttributes = [];
+                            for (const [idn, currentAttr] of currentAttrs) {
+                                const backupAttr = backupAttrs.get(idn);
+                                const hasChanged = !backupAttr ||
+                                    currentAttr.value !== backupAttr.value ||
+                                    currentAttr.title !== backupAttr.title ||
+                                    currentAttr.description !== backupAttr.description ||
+                                    currentAttr.group !== backupAttr.group ||
+                                    currentAttr.is_hidden !== backupAttr.is_hidden;
+                                if (hasChanged) {
+                                    changedAttributes.push(idn);
+                                }
+                            }
+                            if (changedAttributes.length > 0) {
+                                console.log(`  📊 Changed attributes (${changedAttributes.length}):`);
+                                changedAttributes.slice(0, 5).forEach(idn => {
+                                    const current = currentAttrs.get(idn);
+                                    const backup = backupAttrs.get(idn);
+                                    console.log(`    • ${idn}: ${current?.title || 'No title'}`);
+                                    if (verbose) {
+                                        console.log(`      Old: ${backup?.value || 'N/A'}`);
+                                        console.log(`      New: ${current?.value || 'N/A'}`);
+                                    }
+                                });
+                                if (changedAttributes.length > 5) {
+                                    console.log(`    ... and ${changedAttributes.length - 5} more`);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    // Fallback to simple message if diff analysis fails
+                }
+                if (verbose)
+                    console.log(`  🔄 Modified: attributes.yaml`);
+            }
+            else if (verbose) {
+                console.log(`  ✓ Unchanged: attributes.yaml`);
             }
-            // For now, just report the file exists (change detection would require timestamp tracking)
-            if (verbose)
-                console.log(`  ✓ Attributes file tracked`);
         }
     }
     catch (error) {
@@ -512,12 +851,29 @@ export async function status(customer, verbose = false) {
     const flowsFile = flowsYamlPath(customer.idn);
     if (await fs.pathExists(flowsFile)) {
         try {
-            const flowsStats = await fs.stat(flowsFile);
+            const flowsContent = await fs.readFile(flowsFile, 'utf8');
+            const h = sha256(flowsContent);
+            const oldHash = hashes[flowsFile];
             if (verbose) {
                 console.log(`📄 flows.yaml`);
+                console.log(`  Old hash: ${oldHash || 'none'}`);
+                console.log(`  New hash: ${h}`);
+            }
+            if (oldHash !== h) {
+                console.log(`M  ${flowsFile}`);
+                dirty++;
+                if (verbose) {
+                    const flowsStats = await fs.stat(flowsFile);
+                    console.log(`  🔄 Modified: flows.yaml`);
+                    console.log(`  📊 Size: ${(flowsStats.size / 1024).toFixed(1)}KB`);
+                    console.log(`  📅 Last modified: ${flowsStats.mtime.toISOString()}`);
+                }
+            }
+            else if (verbose) {
+                const flowsStats = await fs.stat(flowsFile);
+                console.log(`  ✓ Unchanged: flows.yaml`);
                 console.log(`  📅 Last modified: ${flowsStats.mtime.toISOString()}`);
                 console.log(`  📊 Size: ${(flowsStats.size / 1024).toFixed(1)}KB`);
-                console.log(`  ✓ Flows file tracked`);
             }
         }
         catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "newo",
-  "version": "1.7.2",
-  "description": "NEWO CLI: sync AI Agent skills and customer attributes between NEWO platform and local files. Multi-customer workspaces, Git-first workflows, comprehensive project management.",
+  "version": "1.8.0",
+  "description": "NEWO CLI: comprehensive sync for AI Agent skills, customer attributes, and metadata between NEWO platform and local files. Multi-customer workspaces, complete change tracking, Git-first workflows.",
   "type": "module",
   "bin": {
     "newo": "dist/cli.js"

package/src/fsutil.ts

@@ -47,6 +47,10 @@ export function customerAttributesMapPath(customerIdn: string): string {
   return path.join(customerStateDir(customerIdn), 'attributes-map.json');
 }
 
+export function customerAttributesBackupPath(customerIdn: string): string {
+  return path.join(customerStateDir(customerIdn), 'attributes-backup.yaml');
+}
+
 // Legacy skill path - direct file
 export function skillPath(
   customerIdn: string,

package/src/sync.ts

@@ -6,7 +6,8 @@ import {
   listFlowEvents,
   listFlowStates,
   getProjectMeta,
-  getCustomerAttributes
+  getCustomerAttributes,
+  updateCustomerAttribute
 } from './api.js';
 import {
   ensureState,
@@ -21,7 +22,8 @@ import {
   skillMetadataPath,
   flowsYamlPath,
   customerAttributesPath,
-  customerAttributesMapPath
+  customerAttributesMapPath,
+  customerAttributesBackupPath
 } from './fsutil.js';
 import fs from 'fs-extra';
 import { sha256, loadHashes, saveHashes } from './hash.js';
@@ -46,7 +48,8 @@ import type {
   FlowMetadata,
   SkillMetadata,
   FlowEvent,
-  FlowState
+  FlowState,
+  CustomerAttribute
 } from './types.js';
 
 // Concurrency limits for API operations
@@ -136,13 +139,15 @@ export async function saveCustomerAttributes(
     // Fix JSON string formatting to match reference (remove escape characters)
     yamlContent = yamlContent.replace(/\\"/g, '"');
 
-    // Save both files
+    // Save all files: attributes.yaml, ID mapping, and backup for diff tracking
     await writeFileSafe(customerAttributesPath(customer.idn), yamlContent);
     await writeFileSafe(customerAttributesMapPath(customer.idn), JSON.stringify(idMapping, null, 2));
+    await writeFileSafe(customerAttributesBackupPath(customer.idn), yamlContent);
 
     if (verbose) {
       console.log(`✓ Saved customer attributes to ${customerAttributesPath(customer.idn)}`);
       console.log(`✓ Saved attribute ID mapping to ${customerAttributesMapPath(customer.idn)}`);
+      console.log(`✓ Created attributes backup for diff tracking`);
     }
   } catch (error) {
     console.error(`❌ Failed to save customer attributes for ${customer.idn}:`, error);
@@ -296,21 +301,45 @@ export async function pullAll(
           const content = await fs.readFile(newPath, 'utf8');
           hashes[newPath] = sha256(content);
 
+          // Track skill metadata.yaml file
+          const metadataPath = skillMetadataPath(customer.idn, projectMeta.idn, agentIdn, flowIdn, skillIdn);
+          if (await fs.pathExists(metadataPath)) {
+            const metadataContent = await fs.readFile(metadataPath, 'utf8');
+            hashes[metadataPath] = sha256(metadataContent);
+          }
+
           // Also track legacy path for backwards compatibility during transition
           const legacyPath = skillPath(customer.idn, projectMeta.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
           hashes[legacyPath] = sha256(content);
         }
       }
     }
-    await saveHashes(hashes, customer.idn);
 
-    // Save customer attributes
+    // Save customer attributes before hash tracking
     try {
       await saveCustomerAttributes(client, customer, verbose);
+
+      // Add attributes.yaml to hash tracking
+      const attributesFile = customerAttributesPath(customer.idn);
+      if (await fs.pathExists(attributesFile)) {
+        const attributesContent = await fs.readFile(attributesFile, 'utf8');
+        hashes[attributesFile] = sha256(attributesContent);
+        if (verbose) console.log(`✓ Added attributes.yaml to hash tracking`);
+      }
+
+      // Add flows.yaml to hash tracking
+      const flowsFile = flowsYamlPath(customer.idn);
+      if (await fs.pathExists(flowsFile)) {
+        const flowsContent = await fs.readFile(flowsFile, 'utf8');
+        hashes[flowsFile] = sha256(flowsContent);
+        if (verbose) console.log(`✓ Added flows.yaml to hash tracking`);
+      }
     } catch (error) {
       console.error(`❌ Failed to save customer attributes for ${customer.idn}:`, error);
       // Don't throw - continue with the rest of the process
     }
+
+    await saveHashes(hashes, customer.idn);
     return;
   }
 
@@ -336,6 +365,13 @@ export async function pullAll(
           const content = await fs.readFile(newPath, 'utf8');
           allHashes[newPath] = sha256(content);
 
+          // Track skill metadata.yaml file
+          const metadataPath = skillMetadataPath(customer.idn, project.idn, agentIdn, flowIdn, skillIdn);
+          if (await fs.pathExists(metadataPath)) {
+            const metadataContent = await fs.readFile(metadataPath, 'utf8');
+            allHashes[metadataPath] = sha256(metadataContent);
+          }
+
           // Also track legacy path for backwards compatibility during transition
           const legacyPath = skillPath(customer.idn, project.idn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
           allHashes[legacyPath] = sha256(content);
@@ -345,15 +381,32 @@ export async function pullAll(
   }
 
   await fs.writeJson(mapPath(customer.idn), idMap, { spaces: 2 });
-  await saveHashes(allHashes, customer.idn);
 
-  // Save customer attributes
+  // Save customer attributes before hash tracking
   try {
     await saveCustomerAttributes(client, customer, verbose);
+
+    // Add attributes.yaml to hash tracking
+    const attributesFile = customerAttributesPath(customer.idn);
+    if (await fs.pathExists(attributesFile)) {
+      const attributesContent = await fs.readFile(attributesFile, 'utf8');
+      allHashes[attributesFile] = sha256(attributesContent);
+      if (verbose) console.log(`✓ Added attributes.yaml to hash tracking`);
+    }
+
+    // Add flows.yaml to hash tracking
+    const flowsFile = flowsYamlPath(customer.idn);
+    if (await fs.pathExists(flowsFile)) {
+      const flowsContent = await fs.readFile(flowsFile, 'utf8');
+      allHashes[flowsFile] = sha256(flowsContent);
+      if (verbose) console.log(`✓ Added flows.yaml to hash tracking`);
+    }
   } catch (error) {
     console.error(`❌ Failed to save customer attributes for ${customer.idn}:`, error);
     // Don't throw - continue with the rest of the process
   }
+
+  await saveHashes(allHashes, customer.idn);
 }
 
 export async function pushChanged(client: AxiosInstance, customer: CustomerConfig, verbose: boolean = false): Promise<void> {
@@ -371,6 +424,7 @@ export async function pushChanged(client: AxiosInstance, customer: CustomerConfi
   if (verbose) console.log('🔄 Scanning for changes...');
   let pushed = 0;
   let scanned = 0;
+  let metadataChanged = false;
   
   // Handle both old single-project format and new multi-project format with type guards
   const projects = isProjectMap(idMapData) && idMapData.projects 
@@ -477,27 +531,197 @@ export async function pushChanged(client: AxiosInstance, customer: CustomerConfi
     }
   }
 
+  // Check for metadata-only changes (when metadata changed but script didn't)
+  try {
+    for (const [projectIdn, projectData] of Object.entries(projects)) {
+      for (const [agentIdn, agentObj] of Object.entries(projectData.agents)) {
+        for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
+          for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
+            const metadataPath = projectIdn ?
+              skillMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn) :
+              skillMetadataPath(customer.idn, '', agentIdn, flowIdn, skillIdn);
+
+            if (await fs.pathExists(metadataPath)) {
+              const metadataContent = await fs.readFile(metadataPath, 'utf8');
+              const h = sha256(metadataContent);
+              const oldHash = oldHashes[metadataPath];
+
+              if (oldHash !== h) {
+                if (verbose) console.log(`🔄 Metadata-only change detected for ${skillIdn}, updating skill...`);
+
+                try {
+                  // Load updated metadata
+                  const updatedMetadata = yaml.load(metadataContent) as SkillMetadata;
+
+                  // Get current script content
+                  const scriptPath = projectIdn ?
+                    skillScriptPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn, skillMeta.runner_type) :
+                    skillScriptPath(customer.idn, '', agentIdn, flowIdn, skillIdn, skillMeta.runner_type);
+
+                  let scriptContent = '';
+                  if (await fs.pathExists(scriptPath)) {
+                    scriptContent = await fs.readFile(scriptPath, 'utf8');
+                  }
+
+                  // Create skill object with updated metadata
+                  const skillObject = {
+                    id: updatedMetadata.id,
+                    title: updatedMetadata.title,
+                    idn: updatedMetadata.idn,
+                    prompt_script: scriptContent,
+                    runner_type: updatedMetadata.runner_type,
+                    model: updatedMetadata.model,
+                    parameters: updatedMetadata.parameters,
+                    path: updatedMetadata.path || undefined
+                  };
+
+                  await updateSkill(client, skillObject);
+                  console.log(`↑ Pushed metadata update for skill: ${skillIdn} (${updatedMetadata.title})`);
+
+                  newHashes[metadataPath] = h;
+                  pushed++;
+                  metadataChanged = true;
+
+                } catch (error) {
+                  console.error(`❌ Failed to push metadata for ${skillIdn}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (verbose) console.log(`⚠️  Metadata push check failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
   if (verbose) console.log(`🔄 Scanned ${scanned} files, found ${pushed} changes`);
 
-  // Check for attributes changes and push if needed
+  // Check for attributes changes and push specific changed attributes only
   try {
     const attributesFile = customerAttributesPath(customer.idn);
     const attributesMapFile = customerAttributesMapPath(customer.idn);
+    const attributesBackupFile = customerAttributesBackupPath(customer.idn);
 
     if (await fs.pathExists(attributesFile) && await fs.pathExists(attributesMapFile)) {
       if (verbose) console.log('🔍 Checking customer attributes for changes...');
 
-      // Check file modification time for change detection instead of YAML parsing
-      const attributesStats = await fs.stat(attributesFile);
-      const idMapping = await fs.readJson(attributesMapFile) as Record<string, string>;
+      const currentContent = await fs.readFile(attributesFile, 'utf8');
 
-      // Count attributes by ID mapping instead of parsing YAML (avoids enum parsing issues)
-      const attributeCount = Object.keys(idMapping).length;
+      // Check if backup exists for diff comparison
+      if (await fs.pathExists(attributesBackupFile)) {
+        const backupContent = await fs.readFile(attributesBackupFile, 'utf8');
 
-      if (verbose) {
-        console.log(`📊 Found ${attributeCount} attributes ready for push operations`);
-        console.log(`📅 Attributes file last modified: ${attributesStats.mtime.toISOString()}`);
-        // TODO: Implement change detection by comparing with last push timestamp
+        if (currentContent !== backupContent) {
+          if (verbose) console.log(`🔄 Attributes file changed, analyzing differences...`);
+
+          try {
+            // Load ID mapping for push operations
+            const idMapping = await fs.readJson(attributesMapFile) as Record<string, string>;
+
+            // Parse both versions to find changed attributes
+            const parseYaml = (content: string) => {
+              let yamlContent = content.replace(/!enum "([^"]+)"/g, '"$1"');
+              return yaml.load(yamlContent) as { attributes: any[] };
+            };
+
+            const currentData = parseYaml(currentContent);
+            const backupData = parseYaml(backupContent);
+
+            if (currentData?.attributes && backupData?.attributes) {
+              // Create maps for comparison
+              const currentAttrs = new Map(currentData.attributes.map(attr => [attr.idn, attr]));
+              const backupAttrs = new Map(backupData.attributes.map(attr => [attr.idn, attr]));
+
+              let attributesPushed = 0;
+
+              // Find changed attributes
+              for (const [idn, currentAttr] of currentAttrs) {
+                const backupAttr = backupAttrs.get(idn);
+
+                // Check if attribute changed (deep comparison of key fields)
+                const hasChanged = !backupAttr ||
+                  currentAttr.value !== backupAttr.value ||
+                  currentAttr.title !== backupAttr.title ||
+                  currentAttr.description !== backupAttr.description ||
+                  currentAttr.group !== backupAttr.group ||
+                  currentAttr.is_hidden !== backupAttr.is_hidden;
+
+                if (hasChanged) {
+                  const attributeId = idMapping[idn];
+                  if (!attributeId) {
+                    if (verbose) console.log(`⚠️  Skipping ${idn} - no ID mapping`);
+                    continue;
+                  }
+
+                  // Create attribute object for push
+                  const attributeToUpdate: CustomerAttribute = {
+                    id: attributeId,
+                    idn: currentAttr.idn,
+                    value: currentAttr.value,
+                    title: currentAttr.title || "",
+                    description: currentAttr.description || "",
+                    group: currentAttr.group || "",
+                    is_hidden: currentAttr.is_hidden,
+                    possible_values: currentAttr.possible_values || [],
+                    value_type: currentAttr.value_type?.replace(/^"?AttributeValueTypes\.(.+)"?$/, '$1') || "string"
+                  };
+
+                  await updateCustomerAttribute(client, attributeToUpdate);
+                  attributesPushed++;
+
+                  if (verbose) {
+                    console.log(`  ✓ Pushed changed attribute: ${idn}`);
+                    console.log(`    Old value: ${backupAttr?.value || 'N/A'}`);
+                    console.log(`    New value: ${currentAttr.value}`);
+                  }
+                }
+              }
+
+              if (attributesPushed > 0) {
+                console.log(`↑ Pushed ${attributesPushed} changed customer attributes to NEWO API`);
+
+                // Show summary of what was pushed
+                console.log(`  📊 Pushed attributes:`);
+                for (const [idn, currentAttr] of currentAttrs) {
+                  const backupAttr = backupAttrs.get(idn);
+                  const hasChanged = !backupAttr ||
+                    currentAttr.value !== backupAttr.value ||
+                    currentAttr.title !== backupAttr.title ||
+                    currentAttr.description !== backupAttr.description ||
+                    currentAttr.group !== backupAttr.group ||
+                    currentAttr.is_hidden !== backupAttr.is_hidden;
+
+                  if (hasChanged) {
+                    console.log(`    • ${idn}: ${currentAttr.title || 'No title'}`);
+                    console.log(`      Value: ${currentAttr.value}`);
+                  }
+                }
+
+                // Update backup file after successful push
+                await fs.writeFile(attributesBackupFile, currentContent, 'utf8');
+
+                newHashes[attributesFile] = sha256(currentContent);
+                pushed++;
+              } else if (verbose) {
+                console.log(`  ✓ No attribute value changes detected`);
+              }
+
+            } else {
+              console.log(`⚠️  Failed to parse attributes for comparison`);
+            }
+
+          } catch (error) {
+            console.error(`❌ Failed to push changed attributes: ${error instanceof Error ? error.message : String(error)}`);
+            // Don't update hash/backup on failure so it will retry next time
+          }
+        } else if (verbose) {
+          console.log(`  ✓ No attributes file changes`);
+        }
+      } else {
+        // No backup exists, create initial backup
+        await fs.writeFile(attributesBackupFile, currentContent, 'utf8');
+        if (verbose) console.log(`✓ Created initial attributes backup for diff tracking`);
       }
     } else if (verbose) {
       console.log('ℹ️  No attributes file or ID mapping found for push checking');
@@ -506,6 +730,52 @@ export async function pushChanged(client: AxiosInstance, customer: CustomerConfi
     if (verbose) console.log(`⚠️  Attributes push check failed: ${error instanceof Error ? error.message : String(error)}`);
   }
 
+  // Regenerate flows.yaml if metadata changed
+  if (metadataChanged) {
+    try {
+      if (verbose) console.log('🔄 Metadata changed, regenerating flows.yaml...');
+
+      // Create backup of current flows.yaml for format comparison
+      const flowsFile = flowsYamlPath(customer.idn);
+      let flowsBackup = '';
+      if (await fs.pathExists(flowsFile)) {
+        flowsBackup = await fs.readFile(flowsFile, 'utf8');
+        const backupPath = `${flowsFile}.backup`;
+        await fs.writeFile(backupPath, flowsBackup, 'utf8');
+        if (verbose) console.log(`✓ Created flows.yaml backup at ${backupPath}`);
+      }
+
+      // Re-fetch agents for flows.yaml regeneration
+      const agentsForFlows: Agent[] = [];
+      for (const projectData of Object.values(projects)) {
+        const projectAgents = await listAgents(client, projectData.projectId);
+        agentsForFlows.push(...projectAgents);
+      }
+
+      // Regenerate flows.yaml
+      await generateFlowsYaml(client, customer, agentsForFlows, verbose);
+
+      // Update flows.yaml hash
+      if (await fs.pathExists(flowsFile)) {
+        const newFlowsContent = await fs.readFile(flowsFile, 'utf8');
+        newHashes[flowsFile] = sha256(newFlowsContent);
+
+        // Compare format with backup
+        if (flowsBackup) {
+          const sizeDiff = newFlowsContent.length - flowsBackup.length;
+          if (verbose) {
+            console.log(`✓ Regenerated flows.yaml (size change: ${sizeDiff > 0 ? '+' : ''}${sizeDiff} chars)`);
+          }
+        }
+      }
+
+      console.log('↑ Regenerated flows.yaml due to metadata changes');
+
+    } catch (error) {
+      console.error(`❌ Failed to regenerate flows.yaml: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
   await saveHashes(newHashes, customer.idn);
   console.log(pushed ? `✅ Push complete. ${pushed} file(s) updated.` : '✅ Nothing to push.');
 }
@@ -581,6 +851,51 @@ export async function status(customer: CustomerConfig, verbose: boolean = false)
             console.log(`      ✓ Unchanged: ${currentPath}`);
           }
         }
+
+        // Check metadata.yaml files for changes (after skill files)
+        for (const [skillIdn] of Object.entries(flowObj.skills)) {
+          const metadataPath = projectIdn ?
+            skillMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn) :
+            skillMetadataPath(customer.idn, '', agentIdn, flowIdn, skillIdn);
+
+          if (await fs.pathExists(metadataPath)) {
+            const metadataContent = await fs.readFile(metadataPath, 'utf8');
+            const h = sha256(metadataContent);
+            const oldHash = hashes[metadataPath];
+
+            if (verbose) {
+              console.log(`      📄 ${metadataPath}`);
+              console.log(`        Old hash: ${oldHash || 'none'}`);
+              console.log(`        New hash: ${h}`);
+            }
+
+            if (oldHash !== h) {
+              console.log(`M  ${metadataPath}`);
+              dirty++;
+
+              // Show which metadata fields changed
+              try {
+                const newMetadata = yaml.load(metadataContent) as any;
+
+                console.log(`      📊 Metadata changed for skill: ${skillIdn}`);
+                if (newMetadata?.title) {
+                  console.log(`        • Title: ${newMetadata.title}`);
+                }
+                if (newMetadata?.runner_type) {
+                  console.log(`        • Runner: ${newMetadata.runner_type}`);
+                }
+                if (newMetadata?.model) {
+                  console.log(`        • Model: ${newMetadata.model.provider_idn}/${newMetadata.model.model_idn}`);
+                }
+              } catch (e) {
+                // Fallback to simple message
+                if (verbose) console.log(`      🔄 Modified: metadata.yaml`);
+              }
+            } else if (verbose) {
+              console.log(`      ✓ Unchanged: ${metadataPath}`);
+            }
+          }
+        }
       }
     }
   }
@@ -589,17 +904,79 @@ export async function status(customer: CustomerConfig, verbose: boolean = false)
   try {
     const attributesFile = customerAttributesPath(customer.idn);
     if (await fs.pathExists(attributesFile)) {
-      const attributesStats = await fs.stat(attributesFile);
-      const attributesPath = `${customer.idn}/attributes.yaml`;
+      const content = await fs.readFile(attributesFile, 'utf8');
+      const h = sha256(content);
+      const oldHash = hashes[attributesFile];
 
       if (verbose) {
-        console.log(`📄 ${attributesPath}`);
-        console.log(`  📅 Last modified: ${attributesStats.mtime.toISOString()}`);
-        console.log(`  📊 Size: ${(attributesStats.size / 1024).toFixed(1)}KB`);
+        console.log(`📄 ${attributesFile}`);
+        console.log(`  Old hash: ${oldHash || 'none'}`);
+        console.log(`  New hash: ${h}`);
       }
 
-      // For now, just report the file exists (change detection would require timestamp tracking)
-      if (verbose) console.log(`  ✓ Attributes file tracked`);
+      if (oldHash !== h) {
+        console.log(`M  ${attributesFile}`);
+        dirty++;
+
+        // Show which attributes changed by comparing with backup
+        try {
+          const attributesBackupFile = customerAttributesBackupPath(customer.idn);
+          if (await fs.pathExists(attributesBackupFile)) {
+            const backupContent = await fs.readFile(attributesBackupFile, 'utf8');
+
+            const parseYaml = (content: string) => {
+              let yamlContent = content.replace(/!enum "([^"]+)"/g, '"$1"');
+              return yaml.load(yamlContent) as { attributes: any[] };
+            };
+
+            const currentData = parseYaml(content);
+            const backupData = parseYaml(backupContent);
+
+            if (currentData?.attributes && backupData?.attributes) {
+              const currentAttrs = new Map(currentData.attributes.map(attr => [attr.idn, attr]));
+              const backupAttrs = new Map(backupData.attributes.map(attr => [attr.idn, attr]));
+
+              const changedAttributes: string[] = [];
+
+              for (const [idn, currentAttr] of currentAttrs) {
+                const backupAttr = backupAttrs.get(idn);
+                const hasChanged = !backupAttr ||
+                  currentAttr.value !== backupAttr.value ||
+                  currentAttr.title !== backupAttr.title ||
+                  currentAttr.description !== backupAttr.description ||
+                  currentAttr.group !== backupAttr.group ||
+                  currentAttr.is_hidden !== backupAttr.is_hidden;
+
+                if (hasChanged) {
+                  changedAttributes.push(idn);
+                }
+              }
+
+              if (changedAttributes.length > 0) {
+                console.log(`  📊 Changed attributes (${changedAttributes.length}):`);
+                changedAttributes.slice(0, 5).forEach(idn => {
+                  const current = currentAttrs.get(idn);
+                  const backup = backupAttrs.get(idn);
+                  console.log(`    • ${idn}: ${current?.title || 'No title'}`);
+                  if (verbose) {
+                    console.log(`      Old: ${backup?.value || 'N/A'}`);
+                    console.log(`      New: ${current?.value || 'N/A'}`);
+                  }
+                });
+                if (changedAttributes.length > 5) {
+                  console.log(`    ... and ${changedAttributes.length - 5} more`);
+                }
+              }
+            }
+          }
+        } catch (e) {
+          // Fallback to simple message if diff analysis fails
+        }
+
+        if (verbose) console.log(`  🔄 Modified: attributes.yaml`);
+      } else if (verbose) {
+        console.log(`  ✓ Unchanged: attributes.yaml`);
+      }
     }
   } catch (error) {
     if (verbose) console.log(`⚠️  Error checking attributes: ${error instanceof Error ? error.message : String(error)}`);
@@ -609,12 +986,30 @@ export async function status(customer: CustomerConfig, verbose: boolean = false)
   const flowsFile = flowsYamlPath(customer.idn);
   if (await fs.pathExists(flowsFile)) {
     try {
-      const flowsStats = await fs.stat(flowsFile);
+      const flowsContent = await fs.readFile(flowsFile, 'utf8');
+      const h = sha256(flowsContent);
+      const oldHash = hashes[flowsFile];
+
       if (verbose) {
         console.log(`📄 flows.yaml`);
+        console.log(`  Old hash: ${oldHash || 'none'}`);
+        console.log(`  New hash: ${h}`);
+      }
+
+      if (oldHash !== h) {
+        console.log(`M  ${flowsFile}`);
+        dirty++;
+        if (verbose) {
+          const flowsStats = await fs.stat(flowsFile);
+          console.log(`  🔄 Modified: flows.yaml`);
+          console.log(`  📊 Size: ${(flowsStats.size / 1024).toFixed(1)}KB`);
+          console.log(`  📅 Last modified: ${flowsStats.mtime.toISOString()}`);
+        }
+      } else if (verbose) {
+        const flowsStats = await fs.stat(flowsFile);
+        console.log(`  ✓ Unchanged: flows.yaml`);
         console.log(`  📅 Last modified: ${flowsStats.mtime.toISOString()}`);
         console.log(`  📊 Size: ${(flowsStats.size / 1024).toFixed(1)}KB`);
-        console.log(`  ✓ Flows file tracked`);
       }
     } catch (error) {
       if (verbose) console.log(`⚠️  Error checking flows.yaml: ${error instanceof Error ? error.message : String(error)}`);