n8nac 0.9.9-next.df19681 → 0.9.9-next.e754dc0

package/dist/core/services/{watcher.js → workflow-state-tracker.js}

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import EventEmitter from 'events';
-import chokidar from 'chokidar';
 import { WorkflowTransformerAdapter } from './workflow-transformer-adapter.js';
 import { HashUtils } from './hash-utils.js';
 import { WorkflowSyncStatus } from '../types.js';
@@ -17,8 +16,7 @@ import { WorkflowSyncStatus } from '../types.js';
  *
  * Never performs synchronization actions - only observes reality.
  */
-export class Watcher extends EventEmitter {
-    watcherSubscription = null;
+export class WorkflowStateTracker extends EventEmitter {
     client;
     directory;
     syncInactive;
@@ -26,7 +24,6 @@ export class Watcher extends EventEmitter {
     projectId;
     stateFilePath;
     isConnected = true;
-    isInitializing = false;
     /** True during the first refreshRemoteState() call — suppresses status broadcasts */
     isInitialRemoteLoad = false;
     // Internal state tracking
@@ -36,13 +33,6 @@ export class Watcher extends EventEmitter {
     idToFileMap = new Map(); // workflowId -> filename
     lastKnownStatuses = new Map(); // workflowId or filename -> status
     remoteIds = new Set(); // workflowId
-    // Concurrency control
-    isPaused = new Set(); // IDs for which observation is paused
-    syncInProgress = new Set(); // IDs currently being synced
-    pausedFilenames = new Set(); // Filenames for which observation is paused (for workflows without ID yet)
-    // Potential renames: when we see an add event for a workflow ID that already exists,
-    // we track it here to match with subsequent unlink events
-    potentialRenames = new Map();
     // Lightweight remote state cache
     remoteTimestamps = new Map(); // workflowId -> updatedAt
     /** Canonical display name for each remote workflow (id is the unique key, NOT the name). */
@@ -58,309 +48,12 @@ export class Watcher extends EventEmitter {
         // Restore persisted mappings immediately so 'pull' and other commands can find workflows
         this.restoreMappingsFromState();
     }
-    async start() {
-        if (this.watcherSubscription)
-            return;
-        this.isInitializing = true;
-        // Don't fetch remote state on startup (no batch operations)
-        // Remote state will be populated incrementally through single-workflow fetch operations
-        // Skip connection test - assume connected, will fail on first fetch if not
-        await this.refreshLocalState();
-        // Restore persisted ID → filename mappings from state
-        // This ensures stable filename assignment even when remote workflows have duplicate names
-        this.restoreMappingsFromState();
-        this.isInitializing = false;
-        // Local Watch with Chokidar
-        this.watcherSubscription = chokidar.watch(this.directory, {
-            ignored: [
-                '**/.n8n-state.json',
-                '**/.git/**',
-                /(^|[\/\\])\../
-            ],
-            ignoreInitial: true,
-            persistent: true,
-            awaitWriteFinish: {
-                stabilityThreshold: 100,
-                pollInterval: 50
-            }
-        });
-        // Wait for watcher to be ready
-        await new Promise((resolve) => {
-            this.watcherSubscription?.once('ready', resolve);
-        });
-        this.watcherSubscription
-            .on('add', (filePath) => {
-            const filename = path.basename(filePath);
-            if (filename.startsWith('.'))
-                return;
-            this.onLocalChange(filePath);
-        })
-            .on('change', (filePath) => {
-            const filename = path.basename(filePath);
-            if (filename.startsWith('.'))
-                return;
-            this.onLocalChange(filePath);
-        })
-            .on('unlink', (filePath) => {
-            const filename = path.basename(filePath);
-            if (filename.startsWith('.'))
-                return;
-            this.onLocalDelete(filePath);
-        })
-            .on('error', (error) => {
-            this.emit('error', error);
-        });
-        this.emit('ready');
-    }
-    async stop() {
-        if (this.watcherSubscription) {
-            await this.watcherSubscription.close();
-            this.watcherSubscription = null;
-        }
-    }
     getDirectory() {
         return this.directory;
     }
     getFilenameForId(id) {
         return this.idToFileMap.get(id);
     }
-    /**
-     * Pause observation for a workflow during sync operations
-     */
-    pauseObservation(workflowId) {
-        this.isPaused.add(workflowId);
-    }
-    /**
-     * Resume observation after sync operations
-     */
-    resumeObservation(workflowId) {
-        this.isPaused.delete(workflowId);
-        // Don't force refresh here to avoid unnecessary API calls
-        // In git-like sync, remote state is updated explicitly via fetch command
-    }
-    /**
-     * Pause observation for a filename (for workflows without ID yet)
-     */
-    pauseObservationByFilename(filename) {
-        this.pausedFilenames.add(filename);
-    }
-    /**
-     * Resume observation for a filename
-     */
-    resumeObservationByFilename(filename) {
-        this.pausedFilenames.delete(filename);
-    }
-    /**
-     * Mark a workflow as being synced (prevents race conditions)
-     */
-    markSyncInProgress(workflowId) {
-        this.syncInProgress.add(workflowId);
-    }
-    /**
-     * Mark a workflow as no longer being synced
-     */
-    markSyncComplete(workflowId) {
-        this.syncInProgress.delete(workflowId);
-    }
-    async onLocalChange(filePath) {
-        const filename = path.basename(filePath);
-        console.log(`[Watcher] onLocalChange: ${filename}`);
-        if (!filename.endsWith('.workflow.ts'))
-            return;
-        const content = this.readJsonFile(filePath);
-        if (!content) {
-            console.log(`[Watcher] ❌ Cannot read file content for ${filename} - readJsonFile returned null`);
-            return;
-        }
-        console.log(`[Watcher] ✅ File content read for ${filename}, ID=${content.id}`);
-        // Check if filename is paused (for workflows without ID)
-        if (this.pausedFilenames.has(filename)) {
-            console.log(`[Watcher] ⏸️  Filename ${filename} is paused, ignoring change`);
-            return;
-        }
-        let workflowId = content.id || this.fileToIdMap.get(filename);
-        if (workflowId && (this.isPaused.has(workflowId) || this.syncInProgress.has(workflowId))) {
-            console.log(`[Watcher] ⏸️  Workflow ${workflowId} is paused or sync in progress, ignoring change`);
-            return;
-        }
-        // Check for duplicate ID (following architectural plan)
-        if (content.id) {
-            const existingFilename = this.idToFileMap.get(content.id);
-            if (existingFilename && existingFilename !== filename) {
-                // Check if the existing file still exists on disk
-                const existingFilePath = path.join(this.directory, existingFilename);
-                const fileExists = fs.existsSync(existingFilePath);
-                if (!fileExists) {
-                    // The existing file doesn't exist - this is likely a rename
-                    // Update mappings to point to the new filename
-                    this.fileToIdMap.delete(existingFilename);
-                    this.fileToIdMap.set(filename, content.id);
-                    this.idToFileMap.set(content.id, filename);
-                    // PERSIST: Update filename in state to prevent "ghost" workflows after restart
-                    const state = this.loadState();
-                    if (state.workflows[content.id]) {
-                        state.workflows[content.id].filename = filename;
-                        this.saveState(state);
-                    }
-                    // Emit rename event
-                    this.emit('fileRenamed', {
-                        workflowId: content.id,
-                        oldFilename: existingFilename,
-                        newFilename: filename
-                    });
-                }
-                else {
-                    // File exists - this could be a rename where add happened before unlink
-                    // Track as potential rename and wait for unlink event
-                    this.potentialRenames.set(content.id, {
-                        newFilename: filename,
-                        timestamp: Date.now()
-                    });
-                    // File exists - this is a DUPLICATE ID (copy-paste)
-                    // Principle: Keep ID only in the oldest file, remove from the new one
-                    // DUPLICAT DÉTECTÉ pendant le watch → supprimer l'ID du nouveau fichier
-                    // Remove ID from the new file
-                    const currentContent = this.readJsonFile(filePath);
-                    if (currentContent && currentContent.id === content.id) {
-                        delete currentContent.id;
-                        await this.writeWorkflowFile(filename, currentContent);
-                        // Re-read the TypeScript content and compute hash
-                        const tsContent = fs.readFileSync(filePath, 'utf-8');
-                        try {
-                            const hash = await WorkflowTransformerAdapter.hashWorkflow(tsContent);
-                            const workflowId = this.fileToIdMap.get(filename);
-                            this.localHashes.set(filename, hash);
-                            this.broadcastStatus(filename, workflowId);
-                        }
-                        catch (parseErr) {
-                            console.error(`[Watcher] ❌ Cannot parse "${filename}" after duplicate-ID removal: ${parseErr.message}`);
-                        }
-                    }
-                    return; // Stop processing this file as it's being modified
-                    // Don't return - continue processing as normal
-                    // The unlink event should come soon and trigger rename detection
-                }
-            }
-        }
-        // IMPORTANT: Hash is calculated on the SANITIZED version
-        // This means versionId, versionCounter, pinData, etc. are ignored
-        // The file on disk can contain these fields, but they won't affect the hash
-        const tsContent = fs.readFileSync(filePath, 'utf-8');
-        let hash;
-        try {
-            hash = await WorkflowTransformerAdapter.hashWorkflow(tsContent);
-        }
-        catch (parseErr) {
-            // Parsing failed (e.g. invalid identifier characters like → in the class name
-            // cause ts-morph to silently drop the class body, resulting in a 0-node compile
-            // which would be mistaken as a local modification and pushed, wiping the remote).
-            // Log the problem and abort – do NOT update localHashes so the file is not pushed.
-            console.error(`[Watcher] ❌ Cannot parse "${filename}" – skipping hash/status update to prevent data loss.\n` +
-                `  Cause: ${parseErr.message}\n` +
-                `  Tip: Make sure the class name contains only valid ASCII/identifier characters ` +
-                `(→ U+2192 and similar symbols are not allowed in TypeScript identifiers).`);
-            return;
-        }
-        console.log(`[Watcher] 🔢 Hash computed for ${filename}: ${hash.substring(0, 8)}...`);
-        this.localHashes.set(filename, hash);
-        if (workflowId) {
-            this.fileToIdMap.set(filename, workflowId);
-            this.idToFileMap.set(workflowId, filename);
-        }
-        console.log(`[Watcher] 📡 Broadcasting status for ${filename}...`);
-        this.broadcastStatus(filename, workflowId);
-    }
-    async onLocalDelete(filePath) {
-        const filename = path.basename(filePath);
-        let workflowId = this.fileToIdMap.get(filename);
-        // If workflowId not found via filename mapping, try to find it via state
-        if (!workflowId) {
-            const state = this.loadState();
-            for (const [id, stateData] of Object.entries(state.workflows)) {
-                const mappedFilename = this.idToFileMap.get(id);
-                if (mappedFilename === filename) {
-                    workflowId = id;
-                    break;
-                }
-            }
-        }
-        // Check if this is a potential rename (add happened before unlink)
-        if (workflowId) {
-            const potentialRename = this.potentialRenames.get(workflowId);
-            if (potentialRename) {
-                this.potentialRenames.delete(workflowId);
-                // Handle as rename
-                this.handleRename(workflowId, filename, potentialRename.newFilename);
-                return;
-            }
-        }
-        if (workflowId && (this.isPaused.has(workflowId) || this.syncInProgress.has(workflowId))) {
-            return;
-        }
-        // Handle deletion directly
-        await this.handleLocalDelete(filename, workflowId);
-    }
-    async handleLocalDelete(filename, workflowId) {
-        // Final check: is this actually a rename?
-        if (workflowId) {
-            // Check if the workflow ID appears in another file
-            const otherFilename = this.findFilenameByWorkflowId(workflowId);
-            if (otherFilename && otherFilename !== filename) {
-                // This is a rename, not a deletion!
-                this.handleRename(workflowId, filename, otherFilename);
-                return;
-            }
-        }
-        // When a local file is deleted we simply clear the lastSyncedHash from state
-        // so that calculateStatus() naturally returns EXIST_ONLY_REMOTELY
-        // (remoteHash present, no lastSyncedHash, no localHash).
-        // No archiving is needed here – the remote copy is untouched.
-        if (workflowId) {
-            const state = this.loadState();
-            if (state.workflows[workflowId]) {
-                state.workflows[workflowId].lastSyncedHash = undefined;
-                this.saveState(state);
-            }
-        }
-        // Clean up local hash for deleted file
-        this.localHashes.delete(filename);
-        // Broadcast the new status (EXIST_ONLY_REMOTELY if remote exists, or gone entirely)
-        this.broadcastStatus(filename, workflowId);
-        // CRITICAL: DO NOT delete ID→filename mappings
-        // Mappings must persist so the workflow re-appears with the same filename
-        // when it is pulled again. Mappings are only cleaned up via removeWorkflowState().
-    }
-    handleRename(workflowId, oldFilename, newFilename) {
-        // Update mappings
-        this.fileToIdMap.delete(oldFilename);
-        this.fileToIdMap.set(newFilename, workflowId);
-        this.idToFileMap.set(workflowId, newFilename);
-        // Update local hash mapping
-        const oldHash = this.localHashes.get(oldFilename);
-        if (oldHash) {
-            this.localHashes.delete(oldFilename);
-            this.localHashes.set(newFilename, oldHash);
-        }
-        // PERSIST: Update filename in state to prevent "ghost" workflows after restart
-        if (workflowId) {
-            const state = this.loadState();
-            if (state.workflows[workflowId]) {
-                state.workflows[workflowId].filename = newFilename;
-                this.saveState(state);
-            }
-        }
-        // Emit rename event
-        this.emit('fileRenamed', {
-            workflowId,
-            oldFilename,
-            newFilename
-        });
-        // Broadcast status with new filename
-        this.broadcastStatus(newFilename, workflowId);
-        // Also broadcast status for old filename to clear it from UI
-        // Since it's no longer in localHashes or mappings, it will be handled correctly
-        this.broadcastStatus(oldFilename, undefined);
-    }
     async refreshLocalState() {
         if (!fs.existsSync(this.directory)) {
             console.log(`[DEBUG] refreshLocalState: Directory missing: ${this.directory}`);
@@ -388,8 +81,7 @@ export class Watcher extends EventEmitter {
             const filePath = path.join(this.directory, filename);
             const content = this.readJsonFile(filePath); // Quick ID extraction
             if (content) {
-                const stat = fs.statSync(filePath);
-                fileContents.push({ filename, content, mtime: stat.mtimeMs });
+                fileContents.push({ filename, content });
                 // Compute hash from TypeScript file directly
                 const tsContent = fs.readFileSync(filePath, 'utf-8');
                 try {
@@ -400,7 +92,7 @@ export class Watcher extends EventEmitter {
                         newlyTracked.push(filename);
                 }
                 catch (parseErr) {
-                    console.error(`[Watcher] ❌ Cannot parse "${filename}" during local scan – skipping.\n` +
+                    console.error(`[WorkflowStateTracker] ❌ Cannot parse "${filename}" during local scan – skipping.\n` +
                         `  Cause: ${parseErr.message}\n` +
                         `  Tip: Make sure the class name contains only valid ASCII/identifier characters ` +
                         `(→ U+2192 and similar symbols are not allowed in TypeScript identifiers).`);
@@ -408,29 +100,44 @@ export class Watcher extends EventEmitter {
                 }
             }
         }
-        // Detect and resolve duplicate IDs (following architectural plan)
-        await this.resolveDuplicateIds(fileContents);
-        // Second pass: update mappings after duplicate resolution
-        // CRITICAL: Only update mappings if not already set from persisted state
-        // This prevents ID alternation when remote workflows have duplicate names
+        // Second pass: build file→ID mappings from actual file content (scan-wins).
+        //
+        // For IDs that exist on disk, the scan result is authoritative — this correctly
+        // handles renames (new filename contains the same @workflow({ id: "..." }) decorator).
+        // Mappings for remote-only workflows (set by fetch/updateSingleRemoteState and not
+        // present in local files) are left untouched.
+        //
+        // Duplicate ID handling (copy-paste, option A — no file modification):
+        //   Sort claimants alphabetically → first file wins, others get no mapping
+        //   → treated as EXIST_ONLY_LOCALLY, resolved by pushing (gets a new id)
+        const idClaims = new Map();
         for (const { filename, content } of fileContents) {
             if (content?.id) {
-                // Only update if we don't have a persisted mapping for this ID
-                if (!this.idToFileMap.has(content.id)) {
-                    this.fileToIdMap.set(filename, content.id);
-                    this.idToFileMap.set(content.id, filename);
-                }
-                else {
-                    // We have a persisted mapping - verify it matches the file
-                    const persistedFilename = this.idToFileMap.get(content.id);
-                    if (persistedFilename !== filename) {
-                        // The ID is in a different file than expected
-                        // This can happen if a file was renamed or copied
-                        // We need to decide: keep persisted mapping or update to new file?
-                        // For now, update the reverse mapping but keep ID mapping stable
-                        this.fileToIdMap.set(filename, content.id);
-                    }
-                }
+                if (!idClaims.has(content.id))
+                    idClaims.set(content.id, []);
+                idClaims.get(content.id).push(filename);
+            }
+        }
+        for (const [id, claimants] of idClaims) {
+            // Remove the stale filename entry for this ID before setting the scan result
+            const staleFilename = this.idToFileMap.get(id);
+            if (staleFilename) {
+                this.fileToIdMap.delete(staleFilename);
+            }
+            const sorted = [...claimants].sort();
+            const winner = sorted[0];
+            if (sorted.length > 1) {
+                console.warn(`[WorkflowStateTracker] ⚠️  Duplicate ID "${id}" in [${sorted.join(', ')}]` +
+                    ` → "${winner}" wins (alphabetical). Others treated as new workflows.`);
+            }
+            this.fileToIdMap.set(winner, id);
+            this.idToFileMap.set(id, winner);
+        }
+        // Clean up fileToIdMap entries for files that no longer exist on disk.
+        // (idToFileMap for deleted-locally workflows is intentionally kept for EXIST_ONLY_REMOTELY.)
+        for (const existingFilename of Array.from(this.fileToIdMap.keys())) {
+            if (!currentFiles.has(existingFilename)) {
+                this.fileToIdMap.delete(existingFilename);
             }
         }
         // Broadcast status for newly-tracked files (includes ID-less local-only files)
@@ -441,51 +148,6 @@ export class Watcher extends EventEmitter {
             this.broadcastStatus(filename, workflowId);
         }
     }
-    /**
-     * Resolve duplicate IDs in local files (following architectural plan)
-     * Principle: Keep ID only in the oldest file, remove from others
-     */
-    async resolveDuplicateIds(fileContents) {
-        // Group files by workflow ID
-        const filesById = new Map();
-        for (const { filename, content, mtime } of fileContents) {
-            if (content?.id) {
-                const workflowId = content.id;
-                if (!filesById.has(workflowId)) {
-                    filesById.set(workflowId, []);
-                }
-                filesById.get(workflowId).push({ filename, mtime });
-            }
-        }
-        // For each duplicate ID, keep only in oldest file
-        for (const [workflowId, fileList] of filesById.entries()) {
-            if (fileList.length > 1) {
-                // Sort by modification time (oldest first)
-                fileList.sort((a, b) => a.mtime - b.mtime);
-                const oldestFile = fileList[0].filename;
-                const duplicates = fileList.slice(1);
-                // Remove ID from duplicate files
-                for (const { filename: dupFilename } of duplicates) {
-                    const filePath = path.join(this.directory, dupFilename);
-                    const content = this.readJsonFile(filePath);
-                    if (content) {
-                        delete content.id;
-                        await this.writeWorkflowFile(dupFilename, content);
-                        // Update local hash for the modified file
-                        const tsContent = fs.readFileSync(filePath, 'utf-8');
-                        const hash = await WorkflowTransformerAdapter.hashWorkflow(tsContent);
-                        this.localHashes.set(dupFilename, hash);
-                    }
-                }
-                // Emit event for UI (if needed)
-                this.emit('duplicateIdResolved', {
-                    workflowId,
-                    keptInFilename: oldestFile,
-                    removedFromFilenames: duplicates.map(d => d.filename)
-                });
-            }
-        }
-    }
     /**
      * Lightweight fetch strategy:
      * 1. Fetch only IDs and updatedAt timestamps
@@ -512,8 +174,6 @@ export class Watcher extends EventEmitter {
             for (const wf of remoteWorkflows) {
                 if (this.shouldIgnore(wf))
                     continue;
-                if (this.isPaused.has(wf.id) || this.syncInProgress.has(wf.id))
-                    continue;
                 this.remoteIds.add(wf.id);
                 // Store canonical name keyed by ID (names are NOT unique in n8n)
                 if (wf.name)
@@ -550,16 +210,7 @@ export class Watcher extends EventEmitter {
                     // New workflow - establish mapping
                     this.idToFileMap.set(wf.id, filename);
                     this.fileToIdMap.set(filename, wf.id);
-                    // PERSIST: Save mapping to state so subsequent 'pull' commands can find it
-                    const state = this.loadState();
-                    if (!state.workflows[wf.id]) {
-                        state.workflows[wf.id] = {
-                            filename: filename,
-                            lastSyncedHash: undefined,
-                            lastSyncedAt: undefined
-                        };
-                        this.saveState(state);
-                    }
+                    // No longer persist filename to state (mappings are rebuilt from file scan).
                 }
                 else if (previousFilename !== filename) {
                     // Filename changed
@@ -665,11 +316,9 @@ export class Watcher extends EventEmitter {
      */
     async updateWorkflowState(id, hash, remoteUpdatedAt) {
         const state = this.loadState();
-        const filename = this.idToFileMap.get(id) || '';
         state.workflows[id] = {
             lastSyncedHash: hash,
-            lastSyncedAt: remoteUpdatedAt || new Date().toISOString(),
-            filename: filename
+            lastSyncedAt: remoteUpdatedAt || new Date().toISOString()
         };
         this.saveState(state);
     }
@@ -712,21 +361,12 @@ export class Watcher extends EventEmitter {
         return { workflows: {} };
     }
     /**
-     * Restore ID→filename mappings from persisted state
-     * Should only be called once at startup and after state changes
+     * No-op: file→ID mappings are now built exclusively by refreshLocalState()
+     * which scans the @workflow({ id: "..." }) decorator in each *.workflow.ts.
+     * This guarantees correct reconciliation after a local rename.
      */
     restoreMappingsFromState() {
-        const state = this.loadState();
-        for (const [id, workflowState] of Object.entries(state.workflows)) {
-            const ws = workflowState;
-            if (ws.filename) {
-                // Only set if not already mapped (current session takes precedence)
-                if (!this.idToFileMap.has(id)) {
-                    this.idToFileMap.set(id, ws.filename);
-                    this.fileToIdMap.set(ws.filename, id);
-                }
-            }
-        }
+        // Intentionally empty — mappings are built by refreshLocalState() scan.
     }
     /**
      * Save state to .n8n-state.json
@@ -741,17 +381,15 @@ export class Watcher extends EventEmitter {
         return HashUtils.computeHash(content);
     }
     broadcastStatus(filename, workflowId) {
-        if (this.isInitializing)
-            return;
-        // Suppress during initial remote load — avoids spurious "Change detected" on startup
+        // Suppress during initial remote load — avoids spurious “Change detected” on startup
         if (this.isInitialRemoteLoad)
             return;
         const status = this.calculateStatus(filename, workflowId);
         const key = workflowId || filename;
         const lastStatus = this.lastKnownStatuses.get(key);
-        console.log(`[Watcher] Status for ${filename}: ${status} (last: ${lastStatus || 'none'})`);
+        console.log(`[WorkflowStateTracker] Status for ${filename}: ${status} (last: ${lastStatus || 'none'})`);
         if (status !== lastStatus) {
-            console.log(`[Watcher] 🔔 Status changed! Emitting statusChange event`);
+            console.log(`[WorkflowStateTracker] 🔔 Status changed! Emitting statusChange event`);
             this.lastKnownStatuses.set(key, status);
             this.emit('statusChange', {
                 filename,
@@ -760,7 +398,7 @@ export class Watcher extends EventEmitter {
             });
         }
         else {
-            console.log(`[Watcher] Status unchanged, not emitting event`);
+            console.log(`[WorkflowStateTracker] Status unchanged, not emitting event`);
         }
     }
     calculateStatus(filename, workflowId) {
@@ -779,7 +417,7 @@ export class Watcher extends EventEmitter {
         const lastSyncedHash = baseState?.lastSyncedHash;
         // Debug logging for new files
         if (!workflowId && localHash) {
-            console.log(`[Watcher] 🆕 calculateStatus for NEW file: ${filename}`);
+            console.log(`[WorkflowStateTracker] 🆕 calculateStatus for NEW file: ${filename}`);
             console.log(`  localHash: ${localHash ? localHash.substring(0, 8) : 'none'}`);
             console.log(`  lastSyncedHash: ${lastSyncedHash ? lastSyncedHash.substring(0, 8) : 'none'}`);
             console.log(`  remoteHash: ${remoteHash ? remoteHash.substring(0, 8) : 'none'}`);
@@ -797,22 +435,12 @@ export class Watcher extends EventEmitter {
             const remoteModified = remoteHash && remoteHash !== lastSyncedHash;
             if (localModified && remoteModified)
                 return WorkflowSyncStatus.CONFLICT;
-            if (localModified && remoteHash === lastSyncedHash)
-                return WorkflowSyncStatus.MODIFIED_LOCALLY;
-            // remoteModified && localUnchanged: remote updated but local is untouched.
-            // Remote updated but local untouched — treat as TRACKED, user can pull explicitly.
-            if (remoteModified && localHash === lastSyncedHash)
-                return WorkflowSyncStatus.TRACKED;
-            // localUnchanged && remoteHash unknown (not yet fetched by this watcher instance):
-            // local matches last synced state — safe to report TRACKED.
-            // This prevents a spurious CONFLICT when an external process (CLI, another SyncManager
-            // instance) pulls a workflow and writes lastSyncedHash to state while this watcher has
-            // never fetched the remote hash for the workflow (remoteHashes cache is empty here).
-            if (!localModified)
-                return WorkflowSyncStatus.TRACKED;
+            // All other combinations (single-side or no modification) → TRACKED.
+            // Pull guards detect local modifications via direct hash comparison.
+            return WorkflowSyncStatus.TRACKED;
         }
         // Fallback for edge cases
-        console.warn(`[Watcher] ⚠️  CONFLICT fallback for ${filename}:`, { localHash: !!localHash, remoteHash: !!remoteHash, lastSyncedHash: !!lastSyncedHash, workflowId });
+        console.warn(`[WorkflowStateTracker] ⚠️  CONFLICT fallback for ${filename}:`, { localHash: !!localHash, remoteHash: !!remoteHash, lastSyncedHash: !!lastSyncedHash, workflowId });
         return WorkflowSyncStatus.CONFLICT;
     }
     shouldIgnore(wf) {
@@ -910,15 +538,6 @@ export class Watcher extends EventEmitter {
             return null;
         }
     }
-    async writeWorkflowFile(filename, workflow) {
-        const filePath = path.join(this.directory, filename);
-        // Always write as TypeScript
-        const tsCode = await WorkflowTransformerAdapter.convertToTypeScript(workflow, {
-            format: true,
-            commentStyle: 'verbose'
-        });
-        fs.writeFileSync(filePath, tsCode, 'utf-8');
-    }
     getFileToIdMap() {
         return this.fileToIdMap;
     }
@@ -931,7 +550,7 @@ export class Watcher extends EventEmitter {
     }
     /**
      * Lightweight list of workflows with basic status (local only, remote only, both)
-     * Does NOT compute hashes, compile TypeScript, or determine detailed status (MODIFIED_LOCALLY, CONFLICT)
+     * Does NOT compute hashes, compile TypeScript, or determine detailed status (CONFLICT)
      */
     async getLightweightList() {
         const results = new Map();
@@ -939,17 +558,23 @@ export class Watcher extends EventEmitter {
         // 1. Process all local files (just check existence, no hash computation)
         for (const filename of this.getLocalWorkflowFilenames()) {
             const workflowId = this.fileToIdMap.get(filename);
-            const remoteExists = workflowId ? this.remoteIds.has(workflowId) : false;
+            // A workflow is considered "known on remote" if:
+            //   a) remoteIds has it (populated by refreshRemoteState)
+            //   b) remoteHashes has it (populated by finalizeSync after push/pull)
+            //   c) lastSyncedHash exists in state (written by any CLI/VSCode process,
+            //      survives cross-process CLI operations like resolve)
+            const remoteKnown = workflowId
+                ? (this.remoteIds.has(workflowId)
+                    || this.remoteHashes.has(workflowId)
+                    || !!state.workflows[workflowId]?.lastSyncedHash)
+                : false;
             // Determine basic status
             let status;
-            if (workflowId && remoteExists) {
+            if (workflowId && remoteKnown) {
                 status = WorkflowSyncStatus.TRACKED; // Both exist
             }
-            else if (workflowId && !remoteExists) {
-                status = WorkflowSyncStatus.EXIST_ONLY_LOCALLY; // Local only (but has ID)
-            }
             else {
-                status = WorkflowSyncStatus.EXIST_ONLY_LOCALLY; // New file without ID
+                status = WorkflowSyncStatus.EXIST_ONLY_LOCALLY; // New or not yet pushed
             }
             // Prefer the remote canonical name (keyed by ID, not by name since names are non-unique).
             // For local-only files, extract the name from the @workflow decorator for an accurate display.
@@ -971,9 +596,11 @@ export class Watcher extends EventEmitter {
         }
         // 2. Process all remote workflows not yet in results
         for (const workflowId of this.remoteIds) {
-            // Use persisted filename from state for stability
-            const persistedFilename = state.workflows[workflowId]?.filename;
-            const filename = persistedFilename || this.idToFileMap.get(workflowId) || `${workflowId}.workflow.ts`;
+            // Scan-wins: idToFileMap (rebuilt from @workflow decorator) is authoritative.
+            // Fall back to deprecated persisted filename for old state files during transition.
+            const filename = this.idToFileMap.get(workflowId)
+                || state.workflows[workflowId]?.filename
+                || `${workflowId}.workflow.ts`;
             if (!results.has(filename)) {
                 // Prefer the actual remote name (stored by ID to avoid name-collision issues)
                 // Fallback to filename-derived name only if remote name is not available
@@ -1007,7 +634,7 @@ export class Watcher extends EventEmitter {
             }
         }
         catch (error) {
-            console.debug('[Watcher] Failed to read local directory:', error);
+            console.debug('[WorkflowStateTracker] Failed to read local directory:', error);
         }
         return filenames;
     }
@@ -1031,13 +658,13 @@ export class Watcher extends EventEmitter {
                         }
                     }
                     catch (e) {
-                        console.warn(`[Watcher] Failed to parse local workflow ${filename}:`, e);
+                        console.warn(`[WorkflowStateTracker] Failed to parse local workflow ${filename}:`, e);
                     }
                 }
             }
         }
         catch (error) {
-            console.debug('[Watcher] Failed to load workflow metadata for status matrix:', error);
+            console.debug('[WorkflowStateTracker] Failed to load workflow metadata for status matrix:', error);
         }
         // 1. Process all local files
         for (const [filename, hash] of this.localHashes.entries()) {
@@ -1058,9 +685,11 @@ export class Watcher extends EventEmitter {
         }
         // 2. Process all remote workflows not yet in results
         for (const [workflowId, remoteHash] of this.remoteHashes.entries()) {
-            // Use persisted filename from state for stability
-            const persistedFilename = state.workflows[workflowId]?.filename;
-            const filename = persistedFilename || this.idToFileMap.get(workflowId) || `${workflowId}.workflow.ts`;
+            // Scan-wins: idToFileMap (rebuilt from @workflow decorator) is authoritative.
+            // Fall back to deprecated persisted filename for old state files during transition.
+            const filename = this.idToFileMap.get(workflowId)
+                || state.workflows[workflowId]?.filename
+                || `${workflowId}.workflow.ts`;
             if (!results.has(filename)) {
                 const status = this.calculateStatus(filename, workflowId);
                 const workflow = workflowsMap.get(workflowId);
@@ -1079,9 +708,11 @@ export class Watcher extends EventEmitter {
         }
         // 3. Process tracked but deleted workflows
         for (const id of Object.keys(state.workflows)) {
-            // Use persisted filename from state for stability
-            const persistedFilename = state.workflows[id].filename;
-            const filename = persistedFilename || this.idToFileMap.get(id) || `${id}.workflow.ts`;
+            // Scan-wins: idToFileMap (rebuilt from @workflow decorator) is authoritative.
+            // Fall back to deprecated persisted filename for old state files during transition.
+            const filename = this.idToFileMap.get(id)
+                || state.workflows[id]?.filename
+                || `${id}.workflow.ts`;
             if (!results.has(filename)) {
                 const status = this.calculateStatus(filename, id);
                 const workflow = workflowsMap.get(id);
@@ -1145,7 +776,7 @@ export class Watcher extends EventEmitter {
                 }
             }
             catch (error) {
-                console.warn(`[Watcher] Failed to read local workflow ${filename}:`, error);
+                console.warn(`[WorkflowStateTracker] Failed to read local workflow ${filename}:`, error);
             }
         }
         // 2. For remote-only workflows, fetch from API
@@ -1159,7 +790,7 @@ export class Watcher extends EventEmitter {
                     }
                 }
                 catch (error) {
-                    console.warn(`[Watcher] Failed to fetch remote workflow ${workflowId}:`, error);
+                    console.warn(`[WorkflowStateTracker] Failed to fetch remote workflow ${workflowId}:`, error);
                 }
             }
         }
@@ -1242,16 +873,7 @@ export class Watcher extends EventEmitter {
                 }
                 this.idToFileMap.set(remoteWf.id, filename);
                 this.fileToIdMap.set(filename, remoteWf.id);
-                // PERSIST: Save the derived mapping to state so subsequent 'pull' commands can find it
-                const state = this.loadState();
-                if (!state.workflows[remoteWf.id]) {
-                    state.workflows[remoteWf.id] = {
-                        filename: filename,
-                        lastSyncedHash: undefined,
-                        lastSyncedAt: undefined
-                    };
-                    this.saveState(state);
-                }
+                // No longer persist filename to state (mappings are rebuilt from file scan).
             }
             // Broadcast status update
             const filename = this.idToFileMap.get(remoteWf.id);
@@ -1260,8 +882,8 @@ export class Watcher extends EventEmitter {
             }
         }
         catch (error) {
-            console.error(`[Watcher] Failed to update single remote state for ${remoteWf.id}:`, error);
+            console.error(`[WorkflowStateTracker] Failed to update single remote state for ${remoteWf.id}:`, error);
         }
     }
 }
-//# sourceMappingURL=watcher.js.map
+//# sourceMappingURL=workflow-state-tracker.js.map