diff --git a/data.json b/data.json
index 4f85a5c..83d23fe 100644
--- a/data.json
+++ b/data.json
@@ -1,5 +1,5 @@
 {
   "statusPropertyName": "kanban-status",
   "showNotifications": true,
-  "debugMode": false
+  "debugMode": true
 }
\ No newline at end of file
diff --git a/main.js b/main.js
index 630a79b..e23c8ca 100644
--- a/main.js
+++ b/main.js
@@ -35,13 +35,15 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 const DEFAULT_SETTINGS = {
     statusPropertyName: 'status',
     showNotifications: true,
-    debugMode: true
+    debugMode: false // Default to false for better performance
 };
 class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
     constructor() {
         super(...arguments);
-        // Track processing state to avoid redundant operations
+        // Track active observers to disconnect them when not needed
+        this.currentObserver = null;
         this.isProcessing = false;
+        this.activeKanbanBoard = null;
     }
     onload() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -50,21 +52,29 @@ class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
             yield this.loadSettings();
             // Add status bar item
             this.statusBarItem = this.addStatusBarItem();
-            this.statusBarItem.setText('Kanban Status Updater');
+            this.statusBarItem.setText('KSU: Idle');
             this.statusBarItem.addClass('kanban-status-updater-statusbar');
             // Display startup notification
-            new obsidian.Notice('Kanban Status Updater activated');
+            if (this.settings.showNotifications) {
+                new obsidian.Notice('Kanban Status Updater activated');
+            }
             this.log('Plugin loaded');
-            // Register DOM event listener for drag events
+            // Register DOM event listener for drag events - but only process if active leaf is Kanban
             this.registerDomEvent(document, 'dragend', this.onDragEnd.bind(this));
             this.log('Registered drag event listener');
-            // Set up mutation observer to catch card movements
-            this.setupMutationObserver();
+            // Watch for active leaf changes to only observe the current Kanban board
+            this.registerEvent(this.app.workspace.on('active-leaf-change', this.onActiveLeafChange.bind(this)));
+            // Initial check for active Kanban board
+            this.app.workspace.onLayoutReady(() => {
+                this.checkForActiveKanbanBoard();
+            });
             // Add settings tab
             this.addSettingTab(new KanbanStatusUpdaterSettingTab(this.app, this));
         });
     }
     onunload() {
+        // Disconnect any active observers to prevent memory leaks
+        this.disconnectObservers();
         this.log('Plugin unloaded');
     }
     loadSettings() {
@@ -80,153 +90,188 @@ class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
     // Log helper with debug mode check
     log(message) {
         if (this.settings.debugMode) {
-            console.log(`[Kanban Status Updater] ${message}`);
+            console.log(`[KSU] ${message}`);
             // Update status bar
-            this.statusBarItem.setText(`KSU: ${message.substring(0, 30)}${message.length > 30 ? '...' : ''}`);
-            // Reset status bar after 3 seconds
+            this.statusBarItem.setText(`KSU: ${message.substring(0, 25)}${message.length > 25 ? '...' : ''}`);
+            // Reset status bar after 3 seconds if no other logs happen
             setTimeout(() => {
-                this.statusBarItem.setText('Kanban Status Updater');
+                if (this.activeKanbanBoard) {
+                    this.statusBarItem.setText('KSU: Active');
+                }
+                else {
+                    this.statusBarItem.setText('KSU: Idle');
+                }
             }, 3000);
         }
     }
-    setupMutationObserver() {
-        // Create a mutation observer to monitor DOM changes
-        const observer = new MutationObserver((mutations) => {
-            if (this.isProcessing)
-                return;
-            // Debounce to prevent repeated processing
-            setTimeout(() => {
-                this.handleMutations(mutations);
-            }, 500);
-        });
-        // Start observing once the layout is ready
-        this.app.workspace.onLayoutReady(() => {
-            // First try to observe specific Kanban elements
-            const kanbanBoards = document.querySelectorAll('.kanban-plugin__board');
-            if (kanbanBoards.length > 0) {
-                this.log(`Found ${kanbanBoards.length} Kanban boards`);
-                // Observe each board for changes
-                kanbanBoards.forEach(board => {
-                    observer.observe(board, {
-                        childList: true,
-                        subtree: true
-                    });
-                });
+    // Clean up observers when switching away from a Kanban board
+    disconnectObservers() {
+        if (this.currentObserver) {
+            this.log('Disconnecting observer for performance');
+            this.currentObserver.disconnect();
+            this.currentObserver = null;
+        }
+        this.activeKanbanBoard = null;
+    }
+    // Check if the active leaf is a Kanban board
+    onActiveLeafChange(leaf) {
+        this.checkForActiveKanbanBoard();
+    }
+    checkForActiveKanbanBoard() {
+        var _a;
+        // First disconnect any existing observers
+        this.disconnectObservers();
+        // Get the active leaf
+        const activeLeaf = this.app.workspace.activeLeaf;
+        if (!activeLeaf)
+            return;
+        try {
+            // Find the content element safely
+            let contentEl = null;
+            // Use type assertions to avoid TypeScript errors
+            if (activeLeaf.view) {
+                // Try to access the contentEl property using type assertion
+                // @ts-ignore - contentEl exists but might not be in type definitions
+                contentEl = activeLeaf.view.contentEl;
             }
-            else {
-                // Fall back to observing the entire workspace
-                const workspaceContainer = document.querySelector('.workspace-split');
-                if (workspaceContainer) {
-                    this.log('Observing workspace for Kanban boards');
-                    observer.observe(workspaceContainer, {
-                        childList: true,
-                        subtree: true
-                    });
+            // If that didn't work, try another approach
+            if (!contentEl) {
+                // Try to get the Kanban board directly from the DOM
+                // Leaf containers have 'view-content' elements that contain the actual view
+                const viewContent = (_a = activeLeaf.containerEl) === null || _a === void 0 ? void 0 : _a.querySelector('.view-content');
+                if (viewContent) {
+                    contentEl = viewContent;
                 }
                 else {
-                    // Last resort - observe document body
-                    this.log('Falling back to observing document body');
-                    observer.observe(document.body, {
-                        childList: true,
-                        subtree: true
-                    });
+                    // Last resort - look for Kanban boards anywhere in the workspace
+                    contentEl = document.querySelector('.workspace-leaf.mod-active .view-content');
                 }
             }
-            // Check for existing Kanban items
-            this.scanForKanbanItems();
-        });
+            if (!contentEl) {
+                this.log('Could not access content element for active leaf');
+                return;
+            }
+            // Check if this is a Kanban board
+            const kanbanBoard = contentEl.querySelector('.kanban-plugin__board');
+            if (kanbanBoard) {
+                this.log('Found active Kanban board, setting up observer');
+                this.statusBarItem.setText('KSU: Active');
+                // Store reference to active board
+                this.activeKanbanBoard = kanbanBoard;
+                // Set up observer only for this board
+                this.setupObserverForBoard(kanbanBoard);
+            }
+            else {
+                this.log('Active leaf is not a Kanban board');
+                this.statusBarItem.setText('KSU: Idle');
+            }
+        }
+        catch (error) {
+            this.log(`Error detecting Kanban board: ${error.message}`);
+            this.statusBarItem.setText('KSU: Error');
+        }
     }
-    scanForKanbanItems() {
-        this.log('Scanning for existing Kanban items');
-        const items = document.querySelectorAll('.kanban-plugin__item');
-        this.log(`Found ${items.length} Kanban items`);
+    setupObserverForBoard(boardElement) {
+        // Create a new observer for this specific board
+        this.currentObserver = new MutationObserver((mutations) => {
+            if (this.isProcessing)
+                return;
+            // Simple debounce to prevent rapid-fire processing
+            this.isProcessing = true;
+            setTimeout(() => {
+                this.handleMutations(mutations);
+                this.isProcessing = false;
+            }, 300);
+        });
+        // Observe only this board with minimal options needed
+        this.currentObserver.observe(boardElement, {
+            childList: true,
+            subtree: true,
+            attributes: false // Don't need attribute changes for performance
+        });
+        this.log('Observer set up for active Kanban board');
     }
     handleMutations(mutations) {
-        this.isProcessing = true;
-        this.log(`Processing ${mutations.length} mutations`);
+        if (!this.activeKanbanBoard)
+            return;
         try {
-            // Look for Kanban card movements
-            for (const mutation of mutations) {
+            const max_mutations = 10;
+            // Only process a sample of mutations for performance
+            const mutationsToProcess = mutations.length > max_mutations ?
+                mutations.slice(0, max_mutations) : mutations;
+            this.log(`Got ${mutationsToProcess.length} mutations of ${mutations.length}`);
+            // Look for Kanban items in mutation
+            let i = 0;
+            for (const mutation of mutationsToProcess) {
+                this.log(`Mutation #${++i} - Type: ${mutation.type}`);
                 if (mutation.type === 'childList') {
-                    // Check for Kanban items being added (which happens when cards move)
+                    // Check added nodes for Kanban items
                     for (const node of Array.from(mutation.addedNodes)) {
                         if (node instanceof HTMLElement) {
-                            // Check if this element is or contains a Kanban item
                             this.processElement(node);
                         }
+                        else {
+                            this.log('Added node is not an HTMLElement but a ' + typeof node);
+                            const htmlElement = node;
+                            this.log('Casted to HTMLElement: ' + htmlElement);
+                            this.processElement(htmlElement);
+                        }
                     }
                 }
+                else {
+                    this.log('Ignoring mutation type: ' + mutation.type);
+                }
             }
         }
         catch (error) {
-            this.log(`Error processing mutations: ${error.message}`);
-        }
-        finally {
-            // Reset processing flag after a delay
-            setTimeout(() => {
-                this.isProcessing = false;
-            }, 1000);
+            this.log(`Error in handleMutations: ${error.message}`);
         }
     }
     onDragEnd(event) {
-        this.log('Drag end event detected');
-        if (this.isProcessing) {
-            this.log('Already processing, ignoring drag event');
+        // Only process if we have an active Kanban board
+        if (!this.activeKanbanBoard || this.isProcessing)
             return;
-        }
-        this.isProcessing = true;
         try {
+            this.log('Drag end detected');
+            // Set processing flag to prevent multiple processing
+            this.isProcessing = true;
             const target = event.target;
             if (!target)
                 return;
-            this.log(`Drag ended on element: ${target.tagName}${target.className ? ' with class ' + target.className : ''}`);
-            // Process the dragged element
             this.processElement(target);
         }
         catch (error) {
-            this.log(`Error processing drag event: ${error.message}`);
+            this.log(`Error in onDragEnd: ${error.message}`);
         }
         finally {
-            // Reset processing flag after a delay
+            // Reset processing flag after a delay to debounce
             setTimeout(() => {
                 this.isProcessing = false;
-            }, 1000);
+            }, 300);
         }
     }
     processElement(element) {
         try {
-            // Try different strategies to find the Kanban item
-            // 1. Check if the element itself is a Kanban item
-            if (element.classList.contains('kanban-plugin__item')) {
-                this.log('Element is a Kanban item');
-                this.processKanbanItem(element);
+            // Only process if inside our active Kanban board
+            if (!this.activeKanbanBoard || !element.closest('.kanban-plugin__board')) {
+                this.log('Element NOT in active Kanban board. Skipping.');
                 return;
             }
-            // 2. Check if the element is an item title
-            if (element.classList.contains('kanban-plugin__item-title')) {
-                this.log('Element is a Kanban item title');
-                const itemElement = element.closest('.kanban-plugin__item');
-                if (itemElement) {
-                    this.processKanbanItem(itemElement);
-                    return;
-                }
-            }
-            // 3. Look for Kanban items inside this element
-            const items = element.querySelectorAll('.kanban-plugin__item');
-            if (items.length > 0) {
-                this.log(`Found ${items.length} Kanban items inside element`);
-                // Process the last item (most likely the one that was moved)
-                this.processKanbanItem(items[items.length - 1]);
+            // Use different strategies to find the Kanban item
+            // Check if element is a Kanban item or contains one
+            const kanbanItem = element.classList.contains('kanban-plugin__item')
+                ? element
+                : element.querySelector('.kanban-plugin__item');
+            if (kanbanItem) {
+                this.processKanbanItem(kanbanItem);
                 return;
             }
-            // 4. Check if element is inside a Kanban item
+            // If element is inside a Kanban item, find the parent
             const parentItem = element.closest('.kanban-plugin__item');
             if (parentItem) {
-                this.log('Element is inside a Kanban item');
                 this.processKanbanItem(parentItem);
                 return;
             }
-            this.log('No Kanban items found related to this element');
         }
         catch (error) {
             this.log(`Error in processElement: ${error.message}`);
@@ -234,43 +279,26 @@ class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
     }
     processKanbanItem(itemElement) {
         try {
-            this.log(`Processing Kanban item: ${itemElement.textContent.substring(0, 30)}...`);
-            // 1. Find the column (lane) this item is in
+            // Find the lane (column) this item is in
             const lane = itemElement.closest('.kanban-plugin__lane');
-            if (!lane) {
-                this.log('Could not find lane/column for this item');
+            if (!lane)
                 return;
-            }
-            // 2. Get the column name from the lane header
-            const laneHeader = lane.querySelector('.kanban-plugin__lane-title');
-            if (!laneHeader) {
-                this.log('Could not find lane header');
+            // Get column name from the lane header
+            const laneHeader = lane.querySelector('.kanban-plugin__lane-header-title');
+            if (!laneHeader)
                 return;
-            }
-            this.log(`laneHeader.textContent: ${laneHeader.textContent}`);
             const columnName = laneHeader.textContent.trim();
-            this.log(`Item is in column: "${columnName}"`);
-            // 3. Find the link in the item
-            const titleElement = itemElement.querySelector('.kanban-plugin__item-title');
-            if (!titleElement) {
-                this.log('Could not find item title element');
+            // Find the link inside the item
+            const internalLink = itemElement.querySelector('a.internal-link');
+            if (!internalLink)
                 return;
-            }
-            // Look for an internal link in the markdown content
-            const internalLink = titleElement.querySelector('a.internal-link');
-            if (!internalLink) {
-                this.log('No internal link found in item');
-                return;
-            }
-            // Get the link target (note path)
+            // Get the link path from data-href or href attribute
             const linkPath = internalLink.getAttribute('data-href') ||
                 internalLink.getAttribute('href');
-            if (!linkPath) {
-                this.log('Link has no href or data-href attribute');
+            if (!linkPath)
                 return;
-            }
-            this.log(`Found link to note: "${linkPath}"`);
-            // Update the linked note's status property
+            this.log(`Processing card with link to "${linkPath}" in column "${columnName}"`);
+            // Update the linked note's status
             this.updateNoteStatus(linkPath, columnName);
         }
         catch (error) {
@@ -283,14 +311,14 @@ class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
                 // Find the linked file
                 const file = this.app.metadataCache.getFirstLinkpathDest(notePath, '');
                 if (!file) {
-                    this.log(`Could not find note: ${notePath}`);
-                    new obsidian.Notice(`⚠️ Error: Note "${notePath}" not found`, 3000);
+                    if (this.settings.showNotifications) {
+                        new obsidian.Notice(`⚠️ Note "${notePath}" not found`, 3000);
+                    }
                     return;
                 }
-                this.log(`Found file: ${file.path}`);
                 // Read the file content
                 const content = yield this.app.vault.read(file);
-                // Check if file already has frontmatter
+                // Check for existing frontmatter
                 const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
                 const frontmatterMatch = content.match(frontmatterRegex);
                 let newContent;
@@ -300,9 +328,9 @@ class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
                     const frontmatterText = frontmatterMatch[1];
                     let frontmatterObj;
                     try {
-                        // Parse the frontmatter
+                        // Try to parse the frontmatter
                         frontmatterObj = obsidian.parseYaml(frontmatterText);
-                        // Check for existing status property
+                        // Check if status property already exists
                         if (frontmatterObj[this.settings.statusPropertyName]) {
                             oldStatus = frontmatterObj[this.settings.statusPropertyName];
                         }
@@ -311,12 +339,30 @@ class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
                         this.log(`Error parsing frontmatter: ${e.message}`);
                         frontmatterObj = {};
                     }
-                    // Update the status property
-                    frontmatterObj[this.settings.statusPropertyName] = status;
-                    // Generate new frontmatter text
-                    const newFrontmatterText = obsidian.stringifyYaml(frontmatterObj);
-                    // Replace the frontmatter in the content
-                    newContent = content.replace(frontmatterRegex, `---\n${newFrontmatterText}---`);
+                    // Only update if status has changed
+                    if (frontmatterObj[this.settings.statusPropertyName] !== status) {
+                        // Update the status property
+                        frontmatterObj[this.settings.statusPropertyName] = status;
+                        // Generate new frontmatter text
+                        const newFrontmatterText = obsidian.stringifyYaml(frontmatterObj);
+                        // Replace the frontmatter in the content
+                        newContent = content.replace(frontmatterRegex, `---\n${newFrontmatterText}---`);
+                        // Save the modified content
+                        yield this.app.vault.modify(file, newContent);
+                        // Show notification if enabled
+                        if (this.settings.showNotifications) {
+                            if (oldStatus) {
+                                new obsidian.Notice(`Updated ${this.settings.statusPropertyName}: "${oldStatus}" → "${status}" for ${file.basename}`, 3000);
+                            }
+                            else {
+                                new obsidian.Notice(`Set ${this.settings.statusPropertyName}: "${status}" for ${file.basename}`, 3000);
+                            }
+                        }
+                        this.log(`Updated status for ${file.basename} to "${status}"`);
+                    }
+                    else {
+                        this.log(`Status already set to "${status}" for ${file.basename}, skipping update`);
+                    }
                 }
                 else {
                     // File has no frontmatter, create it
@@ -325,26 +371,48 @@ class KanbanStatusUpdaterPlugin extends obsidian.Plugin {
                     };
                     const frontmatterText = obsidian.stringifyYaml(frontmatterObj);
                     newContent = `---\n${frontmatterText}---\n\n${content}`;
-                }
-                // Save the modified content
-                yield this.app.vault.modify(file, newContent);
-                // Show notification
-                if (this.settings.showNotifications) {
-                    if (oldStatus) {
-                        new obsidian.Notice(`Updated ${this.settings.statusPropertyName}: "${oldStatus}" → "${status}" for ${file.basename}`, 3000);
-                    }
-                    else {
-                        new obsidian.Notice(`Set ${this.settings.statusPropertyName}: "${status}" for ${file.basename}`, 3000);
+                    // Save the modified content
+                    yield this.app.vault.modify(file, newContent);
+                    // Show notification if enabled
+                    if (this.settings.showNotifications) {
+                        new obsidian.Notice(`Added ${this.settings.statusPropertyName}: "${status}" to ${file.basename}`, 3000);
                     }
+                    this.log(`Added frontmatter with status to ${file.basename}`);
                 }
-                this.log(`Successfully updated status for ${file.basename}`);
             }
             catch (error) {
                 this.log(`Error updating note status: ${error.message}`);
-                new obsidian.Notice(`⚠️ Error updating status: ${error.message}`, 3000);
+                if (this.settings.showNotifications) {
+                    new obsidian.Notice(`⚠️ Error updating status: ${error.message}`, 3000);
+                }
             }
         });
     }
+    // Method for the test button to use
+    runTest() {
+        this.log('Running test...');
+        // Make sure we're using the current active board
+        this.checkForActiveKanbanBoard();
+        if (!this.activeKanbanBoard) {
+            new obsidian.Notice('⚠️ No active Kanban board found - open a Kanban board first', 5000);
+            return;
+        }
+        // Find items in the active board
+        const items = this.activeKanbanBoard.querySelectorAll('.kanban-plugin__item');
+        const count = items.length;
+        new obsidian.Notice(`Found ${count} cards in active Kanban board`, 3000);
+        if (count > 0) {
+            // Process the first item with a link
+            for (let i = 0; i < count; i++) {
+                const item = items[i];
+                if (item.querySelector('a.internal-link')) {
+                    new obsidian.Notice(`Testing with card: "${item.textContent.substring(0, 20)}..."`, 3000);
+                    this.processKanbanItem(item);
+                    break;
+                }
+            }
+        }
+    }
 }
 class KanbanStatusUpdaterSettingTab extends obsidian.PluginSettingTab {
     constructor(app, plugin) {
@@ -376,45 +444,47 @@ class KanbanStatusUpdaterSettingTab extends obsidian.PluginSettingTab {
         })));
         new obsidian.Setting(containerEl)
             .setName('Debug Mode')
-            .setDesc('Enable detailed logging to console')
+            .setDesc('Enable detailed logging (reduces performance)')
             .addToggle(toggle => toggle
             .setValue(this.plugin.settings.debugMode)
             .onChange((value) => __awaiter(this, void 0, void 0, function* () {
             this.plugin.settings.debugMode = value;
             yield this.plugin.saveSettings();
-            new obsidian.Notice(`Debug mode ${value ? 'enabled' : 'disabled'}`);
+            if (value) {
+                new obsidian.Notice('Debug mode enabled - check console for logs', 3000);
+            }
+            else {
+                new obsidian.Notice('Debug mode disabled', 3000);
+            }
         })));
         // Add a test button
         new obsidian.Setting(containerEl)
             .setName('Test Plugin')
-            .setDesc('Scan for Kanban items to verify plugin is working')
+            .setDesc('Test with current Kanban board')
             .addButton(button => button
             .setButtonText('Run Test')
             .onClick(() => {
-            new obsidian.Notice('Looking for Kanban items...');
-            const items = document.querySelectorAll('.kanban-plugin__item');
-            new obsidian.Notice(`Found ${items.length} Kanban items`);
-            if (items.length > 0) {
-                this.plugin.processKanbanItem(items[0]);
-            }
+            this.plugin.runTest();
         }));
-        // Add troubleshooting section
-        containerEl.createEl('h3', { text: 'Troubleshooting' });
+        // Performance info
+        containerEl.createEl('h3', { text: 'Performance Optimization' });
         containerEl.createEl('p', {
-            text: 'If the plugin is not working:'
+            text: 'This plugin only monitors the currently active Kanban board to minimize performance impact.'
         });
+        // Troubleshooting section
+        containerEl.createEl('h3', { text: 'Troubleshooting' });
         const list = containerEl.createEl('ul');
         list.createEl('li', {
-            text: 'Ensure the Kanban plugin is installed and enabled'
+            text: 'The plugin only works with the currently open Kanban board'
         });
         list.createEl('li', {
-            text: 'Make sure your Kanban cards contain internal links to notes'
+            text: 'Cards must contain internal links to notes'
         });
         list.createEl('li', {
-            text: 'Try enabling Debug Mode and check the developer console (Ctrl+Shift+I)'
+            text: 'Keep Debug Mode disabled for best performance'
         });
     }
 }
 
 module.exports = KanbanStatusUpdaterPlugin;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","main.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n","import { \n  App, \n  Editor, \n  MarkdownView, \n  Modal, \n  Notice, \n  Plugin, \n  PluginSettingTab,\n  Setting,\n  TFile,\n  parseYaml,\n  stringifyYaml\n} from 'obsidian';\n\ninterface KanbanStatusUpdaterSettings {\n  statusPropertyName: string;\n  showNotifications: boolean;\n  debugMode: boolean;\n}\n\nconst DEFAULT_SETTINGS: KanbanStatusUpdaterSettings = {\n  statusPropertyName: 'status',\n  showNotifications: true,\n  debugMode: true\n}\n\nexport default class KanbanStatusUpdaterPlugin extends Plugin {\n  settings: KanbanStatusUpdaterSettings;\n  statusBarItem: HTMLElement;\n  \n  // Track processing state to avoid redundant operations\n  private isProcessing = false;\n  \n  async onload() {\n      console.log('Loading Kanban Status Updater plugin');\n      \n      // Load settings\n      await this.loadSettings();\n      \n      // Add status bar item\n      this.statusBarItem = this.addStatusBarItem();\n      this.statusBarItem.setText('Kanban Status Updater');\n      this.statusBarItem.addClass('kanban-status-updater-statusbar');\n      \n      // Display startup notification\n      new Notice('Kanban Status Updater activated');\n      this.log('Plugin loaded');\n      \n      // Register DOM event listener for drag events\n      this.registerDomEvent(document, 'dragend', this.onDragEnd.bind(this));\n      this.log('Registered drag event listener');\n      \n      // Set up mutation observer to catch card movements\n      this.setupMutationObserver();\n      \n      // Add settings tab\n      this.addSettingTab(new KanbanStatusUpdaterSettingTab(this.app, this));\n  }\n  \n  onunload() {\n      this.log('Plugin unloaded');\n  }\n  \n  async loadSettings() {\n      this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n  }\n  \n  async saveSettings() {\n      await this.saveData(this.settings);\n  }\n  \n  // Log helper with debug mode check\n  log(message: string) {\n      if (this.settings.debugMode) {\n          console.log(`[Kanban Status Updater] ${message}`);\n          \n          // Update status bar\n          this.statusBarItem.setText(`KSU: ${message.substring(0, 30)}${message.length > 30 ? '...' : ''}`);\n          \n          // Reset status bar after 3 seconds\n          setTimeout(() => {\n              this.statusBarItem.setText('Kanban Status Updater');\n          }, 3000);\n      }\n  }\n  \n  setupMutationObserver() {\n      // Create a mutation observer to monitor DOM changes\n      const observer = new MutationObserver((mutations) => {\n          if (this.isProcessing) return;\n          \n          // Debounce to prevent repeated processing\n          setTimeout(() => {\n              this.handleMutations(mutations);\n          }, 500);\n      });\n      \n      // Start observing once the layout is ready\n      this.app.workspace.onLayoutReady(() => {\n          // First try to observe specific Kanban elements\n          const kanbanBoards = document.querySelectorAll('.kanban-plugin__board');\n          \n          if (kanbanBoards.length > 0) {\n              this.log(`Found ${kanbanBoards.length} Kanban boards`);\n              \n              // Observe each board for changes\n              kanbanBoards.forEach(board => {\n                  observer.observe(board, {\n                      childList: true,\n                      subtree: true\n                  });\n              });\n          } else {\n              // Fall back to observing the entire workspace\n              const workspaceContainer = document.querySelector('.workspace-split');\n              if (workspaceContainer) {\n                  this.log('Observing workspace for Kanban boards');\n                  observer.observe(workspaceContainer, {\n                      childList: true,\n                      subtree: true\n                  });\n              } else {\n                  // Last resort - observe document body\n                  this.log('Falling back to observing document body');\n                  observer.observe(document.body, {\n                      childList: true,\n                      subtree: true\n                  });\n              }\n          }\n          \n          // Check for existing Kanban items\n          this.scanForKanbanItems();\n      });\n  }\n  \n  scanForKanbanItems() {\n      this.log('Scanning for existing Kanban items');\n      const items = document.querySelectorAll('.kanban-plugin__item');\n      this.log(`Found ${items.length} Kanban items`);\n  }\n  \n  handleMutations(mutations: MutationRecord[]) {\n      this.isProcessing = true;\n      this.log(`Processing ${mutations.length} mutations`);\n      \n      try {\n          // Look for Kanban card movements\n          for (const mutation of mutations) {\n              if (mutation.type === 'childList') {\n                  // Check for Kanban items being added (which happens when cards move)\n                  for (const node of Array.from(mutation.addedNodes)) {\n                      if (node instanceof HTMLElement) {\n                          // Check if this element is or contains a Kanban item\n                          this.processElement(node);\n                      }\n                  }\n              }\n          }\n      } catch (error) {\n          this.log(`Error processing mutations: ${error.message}`);\n      } finally {\n          // Reset processing flag after a delay\n          setTimeout(() => {\n              this.isProcessing = false;\n          }, 1000);\n      }\n  }\n  \n  onDragEnd(event: DragEvent) {\n      this.log('Drag end event detected');\n      \n      if (this.isProcessing) {\n          this.log('Already processing, ignoring drag event');\n          return;\n      }\n      \n      this.isProcessing = true;\n      \n      try {\n          const target = event.target as HTMLElement;\n          if (!target) return;\n          \n          this.log(`Drag ended on element: ${target.tagName}${target.className ? ' with class ' + target.className : ''}`);\n          \n          // Process the dragged element\n          this.processElement(target);\n          \n      } catch (error) {\n          this.log(`Error processing drag event: ${error.message}`);\n      } finally {\n          // Reset processing flag after a delay\n          setTimeout(() => {\n              this.isProcessing = false;\n          }, 1000);\n      }\n  }\n  \n  processElement(element: HTMLElement) {\n      try {\n          // Try different strategies to find the Kanban item\n          \n          // 1. Check if the element itself is a Kanban item\n          if (element.classList.contains('kanban-plugin__item')) {\n              this.log('Element is a Kanban item');\n              this.processKanbanItem(element);\n              return;\n          }\n          \n          // 2. Check if the element is an item title\n          if (element.classList.contains('kanban-plugin__item-title')) {\n              this.log('Element is a Kanban item title');\n              const itemElement = element.closest('.kanban-plugin__item') as HTMLElement;\n              if (itemElement) {\n                  this.processKanbanItem(itemElement);\n                  return;\n              }\n          }\n          \n          // 3. Look for Kanban items inside this element\n          const items = element.querySelectorAll('.kanban-plugin__item');\n          if (items.length > 0) {\n              this.log(`Found ${items.length} Kanban items inside element`);\n              // Process the last item (most likely the one that was moved)\n              this.processKanbanItem(items[items.length - 1] as HTMLElement);\n              return;\n          }\n          \n          // 4. Check if element is inside a Kanban item\n          const parentItem = element.closest('.kanban-plugin__item') as HTMLElement;\n          if (parentItem) {\n              this.log('Element is inside a Kanban item');\n              this.processKanbanItem(parentItem);\n              return;\n          }\n          \n          this.log('No Kanban items found related to this element');\n          \n      } catch (error) {\n          this.log(`Error in processElement: ${error.message}`);\n      }\n  }\n  \n  processKanbanItem(itemElement: HTMLElement) {\n      try {\n          this.log(`Processing Kanban item: ${itemElement.textContent.substring(0, 30)}...`);\n          \n          // 1. Find the column (lane) this item is in\n          const lane = itemElement.closest('.kanban-plugin__lane');\n          if (!lane) {\n              this.log('Could not find lane/column for this item');\n              return;\n          }\n          \n          // 2. Get the column name from the lane header\n          const laneHeader = lane.querySelector('.kanban-plugin__lane-title');\n          if (!laneHeader) {\n              this.log('Could not find lane header');\n              return;\n          }\n\n          this.log(`laneHeader.textContent: ${laneHeader.textContent}`);\n          \n          const columnName = laneHeader.textContent.trim();\n          this.log(`Item is in column: \"${columnName}\"`);\n          \n          // 3. Find the link in the item\n          const titleElement = itemElement.querySelector('.kanban-plugin__item-title');\n          if (!titleElement) {\n              this.log('Could not find item title element');\n              return;\n          }\n          \n          // Look for an internal link in the markdown content\n          const internalLink = titleElement.querySelector('a.internal-link');\n          if (!internalLink) {\n              this.log('No internal link found in item');\n              return;\n          }\n          \n          // Get the link target (note path)\n          const linkPath = internalLink.getAttribute('data-href') || \n                          internalLink.getAttribute('href');\n          \n          if (!linkPath) {\n              this.log('Link has no href or data-href attribute');\n              return;\n          }\n          \n          this.log(`Found link to note: \"${linkPath}\"`);\n          \n          // Update the linked note's status property\n          this.updateNoteStatus(linkPath, columnName);\n          \n      } catch (error) {\n          this.log(`Error in processKanbanItem: ${error.message}`);\n      }\n  }\n  \n  async updateNoteStatus(notePath: string, status: string) {\n      try {\n          // Find the linked file\n          const file = this.app.metadataCache.getFirstLinkpathDest(notePath, '');\n          \n          if (!file) {\n              this.log(`Could not find note: ${notePath}`);\n              new Notice(`⚠️ Error: Note \"${notePath}\" not found`, 3000);\n              return;\n          }\n          \n          this.log(`Found file: ${file.path}`);\n          \n          // Read the file content\n          const content = await this.app.vault.read(file);\n          \n          // Check if file already has frontmatter\n          const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---/;\n          const frontmatterMatch = content.match(frontmatterRegex);\n          \n          let newContent;\n          let oldStatus = null;\n          \n          if (frontmatterMatch) {\n              // File has frontmatter\n              const frontmatterText = frontmatterMatch[1];\n              let frontmatterObj;\n              \n              try {\n                  // Parse the frontmatter\n                  frontmatterObj = parseYaml(frontmatterText);\n                  \n                  // Check for existing status property\n                  if (frontmatterObj[this.settings.statusPropertyName]) {\n                      oldStatus = frontmatterObj[this.settings.statusPropertyName];\n                  }\n                  \n              } catch (e) {\n                  this.log(`Error parsing frontmatter: ${e.message}`);\n                  frontmatterObj = {};\n              }\n              \n              // Update the status property\n              frontmatterObj[this.settings.statusPropertyName] = status;\n              \n              // Generate new frontmatter text\n              const newFrontmatterText = stringifyYaml(frontmatterObj);\n              \n              // Replace the frontmatter in the content\n              newContent = content.replace(frontmatterRegex, `---\\n${newFrontmatterText}---`);\n              \n          } else {\n              // File has no frontmatter, create it\n              const frontmatterObj = {\n                  [this.settings.statusPropertyName]: status\n              };\n              \n              const frontmatterText = stringifyYaml(frontmatterObj);\n              newContent = `---\\n${frontmatterText}---\\n\\n${content}`;\n          }\n          \n          // Save the modified content\n          await this.app.vault.modify(file, newContent);\n          \n          // Show notification\n          if (this.settings.showNotifications) {\n              if (oldStatus) {\n                  new Notice(`Updated ${this.settings.statusPropertyName}: \"${oldStatus}\" → \"${status}\" for ${file.basename}`, 3000);\n              } else {\n                  new Notice(`Set ${this.settings.statusPropertyName}: \"${status}\" for ${file.basename}`, 3000);\n              }\n          }\n          \n          this.log(`Successfully updated status for ${file.basename}`);\n          \n      } catch (error) {\n          this.log(`Error updating note status: ${error.message}`);\n          new Notice(`⚠️ Error updating status: ${error.message}`, 3000);\n      }\n  }\n}\n\nclass KanbanStatusUpdaterSettingTab extends PluginSettingTab {\n  plugin: KanbanStatusUpdaterPlugin;\n  \n  constructor(app: App, plugin: KanbanStatusUpdaterPlugin) {\n      super(app, plugin);\n      this.plugin = plugin;\n  }\n  \n  display(): void {\n      const {containerEl} = this;\n      \n      containerEl.empty();\n      containerEl.createEl('h2', {text: 'Kanban Status Updater Settings'});\n      \n      new Setting(containerEl)\n          .setName('Status Property Name')\n          .setDesc('The name of the property to update when a card is moved')\n          .addText(text => text\n              .setPlaceholder('status')\n              .setValue(this.plugin.settings.statusPropertyName)\n              .onChange(async (value) => {\n                  this.plugin.settings.statusPropertyName = value;\n                  await this.plugin.saveSettings();\n              }));\n      \n      new Setting(containerEl)\n          .setName('Show Notifications')\n          .setDesc('Show a notification when a status is updated')\n          .addToggle(toggle => toggle\n              .setValue(this.plugin.settings.showNotifications)\n              .onChange(async (value) => {\n                  this.plugin.settings.showNotifications = value;\n                  await this.plugin.saveSettings();\n              }));\n      \n      new Setting(containerEl)\n          .setName('Debug Mode')\n          .setDesc('Enable detailed logging to console')\n          .addToggle(toggle => toggle\n              .setValue(this.plugin.settings.debugMode)\n              .onChange(async (value) => {\n                  this.plugin.settings.debugMode = value;\n                  await this.plugin.saveSettings();\n                  new Notice(`Debug mode ${value ? 'enabled' : 'disabled'}`);\n              }));\n      \n      // Add a test button\n      new Setting(containerEl)\n          .setName('Test Plugin')\n          .setDesc('Scan for Kanban items to verify plugin is working')\n          .addButton(button => button\n              .setButtonText('Run Test')\n              .onClick(() => {\n                  new Notice('Looking for Kanban items...');\n                  const items = document.querySelectorAll('.kanban-plugin__item');\n                  new Notice(`Found ${items.length} Kanban items`);\n                  \n                  if (items.length > 0) {\n                      this.plugin.processKanbanItem(items[0] as HTMLElement);\n                  }\n              }));\n      \n      // Add troubleshooting section\n      containerEl.createEl('h3', {text: 'Troubleshooting'});\n      \n      containerEl.createEl('p', {\n          text: 'If the plugin is not working:'\n      });\n      \n      const list = containerEl.createEl('ul');\n      \n      list.createEl('li', {\n          text: 'Ensure the Kanban plugin is installed and enabled'\n      });\n      \n      list.createEl('li', {\n          text: 'Make sure your Kanban cards contain internal links to notes'\n      });\n      \n      list.createEl('li', {\n          text: 'Try enabling Debug Mode and check the developer console (Ctrl+Shift+I)'\n      });\n  }\n}\n"],"names":["Plugin","Notice","parseYaml","stringifyYaml","PluginSettingTab","Setting"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","main.ts"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n","import { \n  App, \n  Editor, \n  MarkdownView, \n  Notice, \n  Plugin, \n  PluginSettingTab,\n  Setting,\n  TFile,\n  parseYaml,\n  stringifyYaml,\n  WorkspaceLeaf\n} from 'obsidian';\n\ninterface KanbanStatusUpdaterSettings {\n  statusPropertyName: string;\n  showNotifications: boolean;\n  debugMode: boolean;\n}\n\nconst DEFAULT_SETTINGS: KanbanStatusUpdaterSettings = {\n  statusPropertyName: 'status',\n  showNotifications: true,\n  debugMode: false  // Default to false for better performance\n}\n\nexport default class KanbanStatusUpdaterPlugin extends Plugin {\n  settings: KanbanStatusUpdaterSettings;\n  statusBarItem: HTMLElement;\n  \n  // Track active observers to disconnect them when not needed\n  private currentObserver: MutationObserver | null = null;\n  private isProcessing = false;\n  private activeKanbanBoard: HTMLElement | null = null;\n  \n  async onload() {\n      console.log('Loading Kanban Status Updater plugin');\n      \n      // Load settings\n      await this.loadSettings();\n      \n      // Add status bar item\n      this.statusBarItem = this.addStatusBarItem();\n      this.statusBarItem.setText('KSU: Idle');\n      this.statusBarItem.addClass('kanban-status-updater-statusbar');\n      \n      // Display startup notification\n      if (this.settings.showNotifications) {\n          new Notice('Kanban Status Updater activated');\n      }\n      this.log('Plugin loaded');\n      \n      // Register DOM event listener for drag events - but only process if active leaf is Kanban\n      this.registerDomEvent(document, 'dragend', this.onDragEnd.bind(this));\n      this.log('Registered drag event listener');\n      \n      // Watch for active leaf changes to only observe the current Kanban board\n      this.registerEvent(\n          this.app.workspace.on('active-leaf-change', this.onActiveLeafChange.bind(this))\n      );\n      \n      // Initial check for active Kanban board\n      this.app.workspace.onLayoutReady(() => {\n          this.checkForActiveKanbanBoard();\n      });\n      \n      // Add settings tab\n      this.addSettingTab(new KanbanStatusUpdaterSettingTab(this.app, this));\n  }\n  \n  onunload() {\n      // Disconnect any active observers to prevent memory leaks\n      this.disconnectObservers();\n      this.log('Plugin unloaded');\n  }\n  \n  async loadSettings() {\n      this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n  }\n  \n  async saveSettings() {\n      await this.saveData(this.settings);\n  }\n  \n  // Log helper with debug mode check\n  log(message: string) {\n      if (this.settings.debugMode) {\n          console.log(`[KSU] ${message}`);\n          \n          // Update status bar\n          this.statusBarItem.setText(`KSU: ${message.substring(0, 25)}${message.length > 25 ? '...' : ''}`);\n          \n          // Reset status bar after 3 seconds if no other logs happen\n          setTimeout(() => {\n              if (this.activeKanbanBoard) {\n                  this.statusBarItem.setText('KSU: Active');\n              } else {\n                  this.statusBarItem.setText('KSU: Idle');\n              }\n          }, 3000);\n      }\n  }\n  \n  // Clean up observers when switching away from a Kanban board\n  disconnectObservers() {\n      if (this.currentObserver) {\n          this.log('Disconnecting observer for performance');\n          this.currentObserver.disconnect();\n          this.currentObserver = null;\n      }\n      this.activeKanbanBoard = null;\n  }\n  \n  // Check if the active leaf is a Kanban board\n  onActiveLeafChange(leaf: WorkspaceLeaf) {\n      this.checkForActiveKanbanBoard();\n  }\n  \n  checkForActiveKanbanBoard() {\n    // First disconnect any existing observers\n    this.disconnectObservers();\n    \n    // Get the active leaf\n    const activeLeaf = this.app.workspace.activeLeaf;\n    if (!activeLeaf) return;\n    \n    try {\n        // Find the content element safely\n        let contentEl: HTMLElement | null = null;\n        \n        // Use type assertions to avoid TypeScript errors\n        if (activeLeaf.view) {\n            // Try to access the contentEl property using type assertion\n            // @ts-ignore - contentEl exists but might not be in type definitions\n            contentEl = activeLeaf.view.contentEl;\n        }\n        \n        // If that didn't work, try another approach\n        if (!contentEl) {\n            // Try to get the Kanban board directly from the DOM\n            // Leaf containers have 'view-content' elements that contain the actual view\n            const viewContent = (activeLeaf as any).containerEl?.querySelector('.view-content');\n            if (viewContent) {\n                contentEl = viewContent;\n            } else {\n                // Last resort - look for Kanban boards anywhere in the workspace\n                contentEl = document.querySelector('.workspace-leaf.mod-active .view-content');\n            }\n        }\n        \n        if (!contentEl) {\n            this.log('Could not access content element for active leaf');\n            return;\n        }\n        \n        // Check if this is a Kanban board\n        const kanbanBoard = contentEl.querySelector('.kanban-plugin__board');\n        if (kanbanBoard) {\n            this.log('Found active Kanban board, setting up observer');\n            this.statusBarItem.setText('KSU: Active');\n            \n            // Store reference to active board\n            this.activeKanbanBoard = kanbanBoard as HTMLElement;\n            \n            // Set up observer only for this board\n            this.setupObserverForBoard(kanbanBoard as HTMLElement);\n        } else {\n            this.log('Active leaf is not a Kanban board');\n            this.statusBarItem.setText('KSU: Idle');\n        }\n    } catch (error) {\n        this.log(`Error detecting Kanban board: ${error.message}`);\n        this.statusBarItem.setText('KSU: Error');\n    }\n  }\n  \n  setupObserverForBoard(boardElement: HTMLElement) {\n      // Create a new observer for this specific board\n      this.currentObserver = new MutationObserver((mutations) => {\n          if (this.isProcessing) return;\n          \n          // Simple debounce to prevent rapid-fire processing\n          this.isProcessing = true;\n          setTimeout(() => {\n              this.handleMutations(mutations);\n              this.isProcessing = false;\n          }, 300);\n      });\n      \n      // Observe only this board with minimal options needed\n      this.currentObserver.observe(boardElement, {\n          childList: true,\n          subtree: true,\n          attributes: false // Don't need attribute changes for performance\n      });\n      \n      this.log('Observer set up for active Kanban board');\n  }\n  \n  handleMutations(mutations: MutationRecord[]) {\n      if (!this.activeKanbanBoard) return;\n      \n      try {\n        const max_mutations = 10;\n          // Only process a sample of mutations for performance\n          const mutationsToProcess = mutations.length > max_mutations ? \n              mutations.slice(0, max_mutations) : mutations;\n              \n          this.log(`Got ${mutationsToProcess.length} mutations of ${mutations.length}`);\n          \n          // Look for Kanban items in mutation\n          let i = 0;\n          for (const mutation of mutationsToProcess) {\n              this.log(`Mutation #${++i} - Type: ${mutation.type}`);\n              if (mutation.type === 'childList') {\n                  // Check added nodes for Kanban items\n                  for (const node of Array.from(mutation.addedNodes)) {\n                      if (node instanceof HTMLElement) {\n                          this.processElement(node);\n                      } else {\n                          this.log('Added node is not an HTMLElement but a ' + typeof node);\n                          const htmlElement = node as HTMLElement;\n                          this.log('Casted to HTMLElement: ' + htmlElement);\n                          this.processElement(htmlElement);\n                      }\n                  }\n              } else {\n                  this.log('Ignoring mutation type: ' + mutation.type);\n              }\n          }\n      } catch (error) {\n          this.log(`Error in handleMutations: ${error.message}`);\n      }\n  }\n  \n  onDragEnd(event: DragEvent) {\n      // Only process if we have an active Kanban board\n      if (!this.activeKanbanBoard || this.isProcessing) return;\n      \n      try {\n          this.log('Drag end detected');\n          \n          // Set processing flag to prevent multiple processing\n          this.isProcessing = true;\n          \n          const target = event.target as HTMLElement;\n          if (!target) return;\n          \n          this.processElement(target);\n      } catch (error) {\n          this.log(`Error in onDragEnd: ${error.message}`);\n      } finally {\n          // Reset processing flag after a delay to debounce\n          setTimeout(() => {\n              this.isProcessing = false;\n          }, 300);\n      }\n  }\n  \n  processElement(element: HTMLElement) {\n      try {\n          // Only process if inside our active Kanban board\n          if (!this.activeKanbanBoard || !element.closest('.kanban-plugin__board')) {\n              this.log('Element NOT in active Kanban board. Skipping.');\n              return;\n          }\n          \n          // Use different strategies to find the Kanban item\n          \n          // Check if element is a Kanban item or contains one\n          const kanbanItem = element.classList.contains('kanban-plugin__item') \n              ? element\n              : element.querySelector('.kanban-plugin__item');\n              \n          if (kanbanItem) {\n              this.processKanbanItem(kanbanItem as HTMLElement);\n              return;\n          }\n          \n          // If element is inside a Kanban item, find the parent\n          const parentItem = element.closest('.kanban-plugin__item') as HTMLElement;\n          if (parentItem) {\n              this.processKanbanItem(parentItem);\n              return;\n          }\n      } catch (error) {\n          this.log(`Error in processElement: ${error.message}`);\n      }\n  }\n  \n  processKanbanItem(itemElement: HTMLElement) {\n      try {\n          // Find the lane (column) this item is in\n          const lane = itemElement.closest('.kanban-plugin__lane');\n          if (!lane) return;\n          \n          // Get column name from the lane header\n          const laneHeader = lane.querySelector('.kanban-plugin__lane-header-title');\n          if (!laneHeader) return;\n          \n          const columnName = laneHeader.textContent.trim();\n          \n          // Find the link inside the item\n          const internalLink = itemElement.querySelector('a.internal-link');\n          if (!internalLink) return;\n          \n          // Get the link path from data-href or href attribute\n          const linkPath = internalLink.getAttribute('data-href') || \n                          internalLink.getAttribute('href');\n                          \n          if (!linkPath) return;\n          \n          this.log(`Processing card with link to \"${linkPath}\" in column \"${columnName}\"`);\n          \n          // Update the linked note's status\n          this.updateNoteStatus(linkPath, columnName);\n          \n      } catch (error) {\n          this.log(`Error in processKanbanItem: ${error.message}`);\n      }\n  }\n  \n  async updateNoteStatus(notePath: string, status: string) {\n      try {\n          // Find the linked file\n          const file = this.app.metadataCache.getFirstLinkpathDest(notePath, '');\n          \n          if (!file) {\n              if (this.settings.showNotifications) {\n                  new Notice(`⚠️ Note \"${notePath}\" not found`, 3000);\n              }\n              return;\n          }\n          \n          // Read the file content\n          const content = await this.app.vault.read(file);\n          \n          // Check for existing frontmatter\n          const frontmatterRegex = /^---\\n([\\s\\S]*?)\\n---/;\n          const frontmatterMatch = content.match(frontmatterRegex);\n          \n          let newContent;\n          let oldStatus = null;\n          \n          if (frontmatterMatch) {\n              // File has frontmatter\n              const frontmatterText = frontmatterMatch[1];\n              let frontmatterObj;\n              \n              try {\n                  // Try to parse the frontmatter\n                  frontmatterObj = parseYaml(frontmatterText);\n                  \n                  // Check if status property already exists\n                  if (frontmatterObj[this.settings.statusPropertyName]) {\n                      oldStatus = frontmatterObj[this.settings.statusPropertyName];\n                  }\n                  \n              } catch (e) {\n                  this.log(`Error parsing frontmatter: ${e.message}`);\n                  frontmatterObj = {};\n              }\n              \n              // Only update if status has changed\n              if (frontmatterObj[this.settings.statusPropertyName] !== status) {\n                  // Update the status property\n                  frontmatterObj[this.settings.statusPropertyName] = status;\n                  \n                  // Generate new frontmatter text\n                  const newFrontmatterText = stringifyYaml(frontmatterObj);\n                  \n                  // Replace the frontmatter in the content\n                  newContent = content.replace(frontmatterRegex, `---\\n${newFrontmatterText}---`);\n                  \n                  // Save the modified content\n                  await this.app.vault.modify(file, newContent);\n                  \n                  // Show notification if enabled\n                  if (this.settings.showNotifications) {\n                      if (oldStatus) {\n                          new Notice(`Updated ${this.settings.statusPropertyName}: \"${oldStatus}\" → \"${status}\" for ${file.basename}`, 3000);\n                      } else {\n                          new Notice(`Set ${this.settings.statusPropertyName}: \"${status}\" for ${file.basename}`, 3000);\n                      }\n                  }\n                  \n                  this.log(`Updated status for ${file.basename} to \"${status}\"`);\n              } else {\n                  this.log(`Status already set to \"${status}\" for ${file.basename}, skipping update`);\n              }\n          } else {\n              // File has no frontmatter, create it\n              const frontmatterObj = {\n                  [this.settings.statusPropertyName]: status\n              };\n              \n              const frontmatterText = stringifyYaml(frontmatterObj);\n              newContent = `---\\n${frontmatterText}---\\n\\n${content}`;\n              \n              // Save the modified content\n              await this.app.vault.modify(file, newContent);\n              \n              // Show notification if enabled\n              if (this.settings.showNotifications) {\n                  new Notice(`Added ${this.settings.statusPropertyName}: \"${status}\" to ${file.basename}`, 3000);\n              }\n              \n              this.log(`Added frontmatter with status to ${file.basename}`);\n          }\n      } catch (error) {\n          this.log(`Error updating note status: ${error.message}`);\n          if (this.settings.showNotifications) {\n              new Notice(`⚠️ Error updating status: ${error.message}`, 3000);\n          }\n      }\n  }\n  \n  // Method for the test button to use\n  runTest() {\n      this.log('Running test...');\n      \n      // Make sure we're using the current active board\n      this.checkForActiveKanbanBoard();\n      \n      if (!this.activeKanbanBoard) {\n          new Notice('⚠️ No active Kanban board found - open a Kanban board first', 5000);\n          return;\n      }\n      \n      // Find items in the active board\n      const items = this.activeKanbanBoard.querySelectorAll('.kanban-plugin__item');\n      const count = items.length;\n      \n      new Notice(`Found ${count} cards in active Kanban board`, 3000);\n      \n      if (count > 0) {\n          // Process the first item with a link\n          for (let i = 0; i < count; i++) {\n              const item = items[i] as HTMLElement;\n              if (item.querySelector('a.internal-link')) {\n                  new Notice(`Testing with card: \"${item.textContent.substring(0, 20)}...\"`, 3000);\n                  this.processKanbanItem(item);\n                  break;\n              }\n          }\n      }\n  }\n}\n\nclass KanbanStatusUpdaterSettingTab extends PluginSettingTab {\n  plugin: KanbanStatusUpdaterPlugin;\n  \n  constructor(app: App, plugin: KanbanStatusUpdaterPlugin) {\n      super(app, plugin);\n      this.plugin = plugin;\n  }\n  \n  display(): void {\n      const {containerEl} = this;\n      \n      containerEl.empty();\n      containerEl.createEl('h2', {text: 'Kanban Status Updater Settings'});\n      \n      new Setting(containerEl)\n          .setName('Status Property Name')\n          .setDesc('The name of the property to update when a card is moved')\n          .addText(text => text\n              .setPlaceholder('status')\n              .setValue(this.plugin.settings.statusPropertyName)\n              .onChange(async (value) => {\n                  this.plugin.settings.statusPropertyName = value;\n                  await this.plugin.saveSettings();\n              }));\n      \n      new Setting(containerEl)\n          .setName('Show Notifications')\n          .setDesc('Show a notification when a status is updated')\n          .addToggle(toggle => toggle\n              .setValue(this.plugin.settings.showNotifications)\n              .onChange(async (value) => {\n                  this.plugin.settings.showNotifications = value;\n                  await this.plugin.saveSettings();\n              }));\n      \n      new Setting(containerEl)\n          .setName('Debug Mode')\n          .setDesc('Enable detailed logging (reduces performance)')\n          .addToggle(toggle => toggle\n              .setValue(this.plugin.settings.debugMode)\n              .onChange(async (value) => {\n                  this.plugin.settings.debugMode = value;\n                  await this.plugin.saveSettings();\n                  \n                  if (value) {\n                      new Notice('Debug mode enabled - check console for logs', 3000);\n                  } else {\n                      new Notice('Debug mode disabled', 3000);\n                  }\n              }));\n      \n      // Add a test button\n      new Setting(containerEl)\n          .setName('Test Plugin')\n          .setDesc('Test with current Kanban board')\n          .addButton(button => button\n              .setButtonText('Run Test')\n              .onClick(() => {\n                  this.plugin.runTest();\n              }));\n      \n      // Performance info\n      containerEl.createEl('h3', {text: 'Performance Optimization'});\n      \n      containerEl.createEl('p', {\n          text: 'This plugin only monitors the currently active Kanban board to minimize performance impact.'\n      });\n      \n      // Troubleshooting section\n      containerEl.createEl('h3', {text: 'Troubleshooting'});\n      \n      const list = containerEl.createEl('ul');\n      \n      list.createEl('li', {\n          text: 'The plugin only works with the currently open Kanban board'\n      });\n      \n      list.createEl('li', {\n          text: 'Cards must contain internal links to notes'\n      });\n      \n      list.createEl('li', {\n          text: 'Keep Debug Mode disabled for best performance'\n      });\n  }\n}"],"names":["Plugin","Notice","parseYaml","stringifyYaml","PluginSettingTab","Setting"],"mappings":"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"}
diff --git a/main.ts b/main.ts
index 079414c..216e0c3 100644
--- a/main.ts
+++ b/main.ts
@@ -2,14 +2,14 @@ import {
   App, 
   Editor, 
   MarkdownView, 
-  Modal, 
   Notice, 
   Plugin, 
   PluginSettingTab,
   Setting,
   TFile,
   parseYaml,
-  stringifyYaml
+  stringifyYaml,
+  WorkspaceLeaf
 } from 'obsidian';
 
 interface KanbanStatusUpdaterSettings {
@@ -21,15 +21,17 @@ interface KanbanStatusUpdaterSettings {
 const DEFAULT_SETTINGS: KanbanStatusUpdaterSettings = {
   statusPropertyName: 'status',
   showNotifications: true,
-  debugMode: true
+  debugMode: false  // Default to false for better performance
 }
 
 export default class KanbanStatusUpdaterPlugin extends Plugin {
   settings: KanbanStatusUpdaterSettings;
   statusBarItem: HTMLElement;
   
-  // Track processing state to avoid redundant operations
+  // Track active observers to disconnect them when not needed
+  private currentObserver: MutationObserver | null = null;
   private isProcessing = false;
+  private activeKanbanBoard: HTMLElement | null = null;
   
   async onload() {
       console.log('Loading Kanban Status Updater plugin');
@@ -39,25 +41,36 @@ export default class KanbanStatusUpdaterPlugin extends Plugin {
       
       // Add status bar item
       this.statusBarItem = this.addStatusBarItem();
-      this.statusBarItem.setText('Kanban Status Updater');
+      this.statusBarItem.setText('KSU: Idle');
       this.statusBarItem.addClass('kanban-status-updater-statusbar');
       
       // Display startup notification
-      new Notice('Kanban Status Updater activated');
+      if (this.settings.showNotifications) {
+          new Notice('Kanban Status Updater activated');
+      }
       this.log('Plugin loaded');
       
-      // Register DOM event listener for drag events
+      // Register DOM event listener for drag events - but only process if active leaf is Kanban
       this.registerDomEvent(document, 'dragend', this.onDragEnd.bind(this));
       this.log('Registered drag event listener');
       
-      // Set up mutation observer to catch card movements
-      this.setupMutationObserver();
+      // Watch for active leaf changes to only observe the current Kanban board
+      this.registerEvent(
+          this.app.workspace.on('active-leaf-change', this.onActiveLeafChange.bind(this))
+      );
+      
+      // Initial check for active Kanban board
+      this.app.workspace.onLayoutReady(() => {
+          this.checkForActiveKanbanBoard();
+      });
       
       // Add settings tab
       this.addSettingTab(new KanbanStatusUpdaterSettingTab(this.app, this));
   }
   
   onunload() {
+      // Disconnect any active observers to prevent memory leaks
+      this.disconnectObservers();
       this.log('Plugin unloaded');
   }
   
@@ -72,170 +85,204 @@ export default class KanbanStatusUpdaterPlugin extends Plugin {
   // Log helper with debug mode check
   log(message: string) {
       if (this.settings.debugMode) {
-          console.log(`[Kanban Status Updater] ${message}`);
+          console.log(`[KSU] ${message}`);
           
           // Update status bar
-          this.statusBarItem.setText(`KSU: ${message.substring(0, 30)}${message.length > 30 ? '...' : ''}`);
+          this.statusBarItem.setText(`KSU: ${message.substring(0, 25)}${message.length > 25 ? '...' : ''}`);
           
-          // Reset status bar after 3 seconds
+          // Reset status bar after 3 seconds if no other logs happen
           setTimeout(() => {
-              this.statusBarItem.setText('Kanban Status Updater');
+              if (this.activeKanbanBoard) {
+                  this.statusBarItem.setText('KSU: Active');
+              } else {
+                  this.statusBarItem.setText('KSU: Idle');
+              }
           }, 3000);
       }
   }
   
-  setupMutationObserver() {
-      // Create a mutation observer to monitor DOM changes
-      const observer = new MutationObserver((mutations) => {
-          if (this.isProcessing) return;
-          
-          // Debounce to prevent repeated processing
-          setTimeout(() => {
-              this.handleMutations(mutations);
-          }, 500);
-      });
-      
-      // Start observing once the layout is ready
-      this.app.workspace.onLayoutReady(() => {
-          // First try to observe specific Kanban elements
-          const kanbanBoards = document.querySelectorAll('.kanban-plugin__board');
-          
-          if (kanbanBoards.length > 0) {
-              this.log(`Found ${kanbanBoards.length} Kanban boards`);
-              
-              // Observe each board for changes
-              kanbanBoards.forEach(board => {
-                  observer.observe(board, {
-                      childList: true,
-                      subtree: true
-                  });
-              });
-          } else {
-              // Fall back to observing the entire workspace
-              const workspaceContainer = document.querySelector('.workspace-split');
-              if (workspaceContainer) {
-                  this.log('Observing workspace for Kanban boards');
-                  observer.observe(workspaceContainer, {
-                      childList: true,
-                      subtree: true
-                  });
-              } else {
-                  // Last resort - observe document body
-                  this.log('Falling back to observing document body');
-                  observer.observe(document.body, {
-                      childList: true,
-                      subtree: true
-                  });
-              }
-          }
-          
-          // Check for existing Kanban items
-          this.scanForKanbanItems();
-      });
+  // Clean up observers when switching away from a Kanban board
+  disconnectObservers() {
+      if (this.currentObserver) {
+          this.log('Disconnecting observer for performance');
+          this.currentObserver.disconnect();
+          this.currentObserver = null;
+      }
+      this.activeKanbanBoard = null;
   }
   
-  scanForKanbanItems() {
-      this.log('Scanning for existing Kanban items');
-      const items = document.querySelectorAll('.kanban-plugin__item');
-      this.log(`Found ${items.length} Kanban items`);
+  // Check if the active leaf is a Kanban board
+  onActiveLeafChange(leaf: WorkspaceLeaf) {
+      this.checkForActiveKanbanBoard();
+  }
+  
+  checkForActiveKanbanBoard() {
+    // First disconnect any existing observers
+    this.disconnectObservers();
+    
+    // Get the active leaf
+    const activeLeaf = this.app.workspace.activeLeaf;
+    if (!activeLeaf) return;
+    
+    try {
+        // Find the content element safely
+        let contentEl: HTMLElement | null = null;
+        
+        // Use type assertions to avoid TypeScript errors
+        if (activeLeaf.view) {
+            // Try to access the contentEl property using type assertion
+            // @ts-ignore - contentEl exists but might not be in type definitions
+            contentEl = activeLeaf.view.contentEl;
+        }
+        
+        // If that didn't work, try another approach
+        if (!contentEl) {
+            // Try to get the Kanban board directly from the DOM
+            // Leaf containers have 'view-content' elements that contain the actual view
+            const viewContent = (activeLeaf as any).containerEl?.querySelector('.view-content');
+            if (viewContent) {
+                contentEl = viewContent;
+            } else {
+                // Last resort - look for Kanban boards anywhere in the workspace
+                contentEl = document.querySelector('.workspace-leaf.mod-active .view-content');
+            }
+        }
+        
+        if (!contentEl) {
+            this.log('Could not access content element for active leaf');
+            return;
+        }
+        
+        // Check if this is a Kanban board
+        const kanbanBoard = contentEl.querySelector('.kanban-plugin__board');
+        if (kanbanBoard) {
+            this.log('Found active Kanban board, setting up observer');
+            this.statusBarItem.setText('KSU: Active');
+            
+            // Store reference to active board
+            this.activeKanbanBoard = kanbanBoard as HTMLElement;
+            
+            // Set up observer only for this board
+            this.setupObserverForBoard(kanbanBoard as HTMLElement);
+        } else {
+            this.log('Active leaf is not a Kanban board');
+            this.statusBarItem.setText('KSU: Idle');
+        }
+    } catch (error) {
+        this.log(`Error detecting Kanban board: ${error.message}`);
+        this.statusBarItem.setText('KSU: Error');
+    }
+  }
+  
+  setupObserverForBoard(boardElement: HTMLElement) {
+      // Create a new observer for this specific board
+      this.currentObserver = new MutationObserver((mutations) => {
+          if (this.isProcessing) return;
+          
+          // Simple debounce to prevent rapid-fire processing
+          this.isProcessing = true;
+          setTimeout(() => {
+              this.handleMutations(mutations);
+              this.isProcessing = false;
+          }, 300);
+      });
+      
+      // Observe only this board with minimal options needed
+      this.currentObserver.observe(boardElement, {
+          childList: true,
+          subtree: true,
+          attributes: false // Don't need attribute changes for performance
+      });
+      
+      this.log('Observer set up for active Kanban board');
   }
   
   handleMutations(mutations: MutationRecord[]) {
-      this.isProcessing = true;
-      this.log(`Processing ${mutations.length} mutations`);
+      if (!this.activeKanbanBoard) return;
       
       try {
-          // Look for Kanban card movements
-          for (const mutation of mutations) {
+        const max_mutations = 10;
+          // Only process a sample of mutations for performance
+          const mutationsToProcess = mutations.length > max_mutations ? 
+              mutations.slice(0, max_mutations) : mutations;
+              
+          this.log(`Got ${mutationsToProcess.length} mutations of ${mutations.length}`);
+          
+          // Look for Kanban items in mutation
+          let i = 0;
+          for (const mutation of mutationsToProcess) {
+              this.log(`Mutation #${++i} - Type: ${mutation.type}`);
               if (mutation.type === 'childList') {
-                  // Check for Kanban items being added (which happens when cards move)
+                  // Check added nodes for Kanban items
                   for (const node of Array.from(mutation.addedNodes)) {
                       if (node instanceof HTMLElement) {
-                          // Check if this element is or contains a Kanban item
                           this.processElement(node);
+                      } else {
+                          this.log('Added node is not an HTMLElement but a ' + typeof node);
+                          const htmlElement = node as HTMLElement;
+                          this.log('Casted to HTMLElement: ' + htmlElement);
+                          this.processElement(htmlElement);
                       }
                   }
+              } else {
+                  this.log('Ignoring mutation type: ' + mutation.type);
               }
           }
       } catch (error) {
-          this.log(`Error processing mutations: ${error.message}`);
-      } finally {
-          // Reset processing flag after a delay
-          setTimeout(() => {
-              this.isProcessing = false;
-          }, 1000);
+          this.log(`Error in handleMutations: ${error.message}`);
       }
   }
   
   onDragEnd(event: DragEvent) {
-      this.log('Drag end event detected');
-      
-      if (this.isProcessing) {
-          this.log('Already processing, ignoring drag event');
-          return;
-      }
-      
-      this.isProcessing = true;
+      // Only process if we have an active Kanban board
+      if (!this.activeKanbanBoard || this.isProcessing) return;
       
       try {
+          this.log('Drag end detected');
+          
+          // Set processing flag to prevent multiple processing
+          this.isProcessing = true;
+          
           const target = event.target as HTMLElement;
           if (!target) return;
           
-          this.log(`Drag ended on element: ${target.tagName}${target.className ? ' with class ' + target.className : ''}`);
-          
-          // Process the dragged element
           this.processElement(target);
-          
       } catch (error) {
-          this.log(`Error processing drag event: ${error.message}`);
+          this.log(`Error in onDragEnd: ${error.message}`);
       } finally {
-          // Reset processing flag after a delay
+          // Reset processing flag after a delay to debounce
           setTimeout(() => {
               this.isProcessing = false;
-          }, 1000);
+          }, 300);
       }
   }
   
   processElement(element: HTMLElement) {
       try {
-          // Try different strategies to find the Kanban item
-          
-          // 1. Check if the element itself is a Kanban item
-          if (element.classList.contains('kanban-plugin__item')) {
-              this.log('Element is a Kanban item');
-              this.processKanbanItem(element);
+          // Only process if inside our active Kanban board
+          if (!this.activeKanbanBoard || !element.closest('.kanban-plugin__board')) {
+              this.log('Element NOT in active Kanban board. Skipping.');
               return;
           }
           
-          // 2. Check if the element is an item title
-          if (element.classList.contains('kanban-plugin__item-title')) {
-              this.log('Element is a Kanban item title');
-              const itemElement = element.closest('.kanban-plugin__item') as HTMLElement;
-              if (itemElement) {
-                  this.processKanbanItem(itemElement);
-                  return;
-              }
-          }
+          // Use different strategies to find the Kanban item
           
-          // 3. Look for Kanban items inside this element
-          const items = element.querySelectorAll('.kanban-plugin__item');
-          if (items.length > 0) {
-              this.log(`Found ${items.length} Kanban items inside element`);
-              // Process the last item (most likely the one that was moved)
-              this.processKanbanItem(items[items.length - 1] as HTMLElement);
+          // Check if element is a Kanban item or contains one
+          const kanbanItem = element.classList.contains('kanban-plugin__item') 
+              ? element
+              : element.querySelector('.kanban-plugin__item');
+              
+          if (kanbanItem) {
+              this.processKanbanItem(kanbanItem as HTMLElement);
               return;
           }
           
-          // 4. Check if element is inside a Kanban item
+          // If element is inside a Kanban item, find the parent
           const parentItem = element.closest('.kanban-plugin__item') as HTMLElement;
           if (parentItem) {
-              this.log('Element is inside a Kanban item');
               this.processKanbanItem(parentItem);
               return;
           }
-          
-          this.log('No Kanban items found related to this element');
-          
       } catch (error) {
           this.log(`Error in processElement: ${error.message}`);
       }
@@ -243,53 +290,29 @@ export default class KanbanStatusUpdaterPlugin extends Plugin {
   
   processKanbanItem(itemElement: HTMLElement) {
       try {
-          this.log(`Processing Kanban item: ${itemElement.textContent.substring(0, 30)}...`);
-          
-          // 1. Find the column (lane) this item is in
+          // Find the lane (column) this item is in
           const lane = itemElement.closest('.kanban-plugin__lane');
-          if (!lane) {
-              this.log('Could not find lane/column for this item');
-              return;
-          }
+          if (!lane) return;
           
-          // 2. Get the column name from the lane header
-          const laneHeader = lane.querySelector('.kanban-plugin__lane-title');
-          if (!laneHeader) {
-              this.log('Could not find lane header');
-              return;
-          }
-
-          this.log(`laneHeader.textContent: ${laneHeader.textContent}`);
+          // Get column name from the lane header
+          const laneHeader = lane.querySelector('.kanban-plugin__lane-header-title');
+          if (!laneHeader) return;
           
           const columnName = laneHeader.textContent.trim();
-          this.log(`Item is in column: "${columnName}"`);
           
-          // 3. Find the link in the item
-          const titleElement = itemElement.querySelector('.kanban-plugin__item-title');
-          if (!titleElement) {
-              this.log('Could not find item title element');
-              return;
-          }
+          // Find the link inside the item
+          const internalLink = itemElement.querySelector('a.internal-link');
+          if (!internalLink) return;
           
-          // Look for an internal link in the markdown content
-          const internalLink = titleElement.querySelector('a.internal-link');
-          if (!internalLink) {
-              this.log('No internal link found in item');
-              return;
-          }
-          
-          // Get the link target (note path)
+          // Get the link path from data-href or href attribute
           const linkPath = internalLink.getAttribute('data-href') || 
                           internalLink.getAttribute('href');
+                          
+          if (!linkPath) return;
           
-          if (!linkPath) {
-              this.log('Link has no href or data-href attribute');
-              return;
-          }
+          this.log(`Processing card with link to "${linkPath}" in column "${columnName}"`);
           
-          this.log(`Found link to note: "${linkPath}"`);
-          
-          // Update the linked note's status property
+          // Update the linked note's status
           this.updateNoteStatus(linkPath, columnName);
           
       } catch (error) {
@@ -303,17 +326,16 @@ export default class KanbanStatusUpdaterPlugin extends Plugin {
           const file = this.app.metadataCache.getFirstLinkpathDest(notePath, '');
           
           if (!file) {
-              this.log(`Could not find note: ${notePath}`);
-              new Notice(`⚠️ Error: Note "${notePath}" not found`, 3000);
+              if (this.settings.showNotifications) {
+                  new Notice(`⚠️ Note "${notePath}" not found`, 3000);
+              }
               return;
           }
           
-          this.log(`Found file: ${file.path}`);
-          
           // Read the file content
           const content = await this.app.vault.read(file);
           
-          // Check if file already has frontmatter
+          // Check for existing frontmatter
           const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
           const frontmatterMatch = content.match(frontmatterRegex);
           
@@ -326,10 +348,10 @@ export default class KanbanStatusUpdaterPlugin extends Plugin {
               let frontmatterObj;
               
               try {
-                  // Parse the frontmatter
+                  // Try to parse the frontmatter
                   frontmatterObj = parseYaml(frontmatterText);
                   
-                  // Check for existing status property
+                  // Check if status property already exists
                   if (frontmatterObj[this.settings.statusPropertyName]) {
                       oldStatus = frontmatterObj[this.settings.statusPropertyName];
                   }
@@ -339,15 +361,33 @@ export default class KanbanStatusUpdaterPlugin extends Plugin {
                   frontmatterObj = {};
               }
               
-              // Update the status property
-              frontmatterObj[this.settings.statusPropertyName] = status;
-              
-              // Generate new frontmatter text
-              const newFrontmatterText = stringifyYaml(frontmatterObj);
-              
-              // Replace the frontmatter in the content
-              newContent = content.replace(frontmatterRegex, `---\n${newFrontmatterText}---`);
-              
+              // Only update if status has changed
+              if (frontmatterObj[this.settings.statusPropertyName] !== status) {
+                  // Update the status property
+                  frontmatterObj[this.settings.statusPropertyName] = status;
+                  
+                  // Generate new frontmatter text
+                  const newFrontmatterText = stringifyYaml(frontmatterObj);
+                  
+                  // Replace the frontmatter in the content
+                  newContent = content.replace(frontmatterRegex, `---\n${newFrontmatterText}---`);
+                  
+                  // Save the modified content
+                  await this.app.vault.modify(file, newContent);
+                  
+                  // Show notification if enabled
+                  if (this.settings.showNotifications) {
+                      if (oldStatus) {
+                          new Notice(`Updated ${this.settings.statusPropertyName}: "${oldStatus}" → "${status}" for ${file.basename}`, 3000);
+                      } else {
+                          new Notice(`Set ${this.settings.statusPropertyName}: "${status}" for ${file.basename}`, 3000);
+                      }
+                  }
+                  
+                  this.log(`Updated status for ${file.basename} to "${status}"`);
+              } else {
+                  this.log(`Status already set to "${status}" for ${file.basename}, skipping update`);
+              }
           } else {
               // File has no frontmatter, create it
               const frontmatterObj = {
@@ -356,25 +396,53 @@ export default class KanbanStatusUpdaterPlugin extends Plugin {
               
               const frontmatterText = stringifyYaml(frontmatterObj);
               newContent = `---\n${frontmatterText}---\n\n${content}`;
-          }
-          
-          // Save the modified content
-          await this.app.vault.modify(file, newContent);
-          
-          // Show notification
-          if (this.settings.showNotifications) {
-              if (oldStatus) {
-                  new Notice(`Updated ${this.settings.statusPropertyName}: "${oldStatus}" → "${status}" for ${file.basename}`, 3000);
-              } else {
-                  new Notice(`Set ${this.settings.statusPropertyName}: "${status}" for ${file.basename}`, 3000);
+              
+              // Save the modified content
+              await this.app.vault.modify(file, newContent);
+              
+              // Show notification if enabled
+              if (this.settings.showNotifications) {
+                  new Notice(`Added ${this.settings.statusPropertyName}: "${status}" to ${file.basename}`, 3000);
               }
+              
+              this.log(`Added frontmatter with status to ${file.basename}`);
           }
-          
-          this.log(`Successfully updated status for ${file.basename}`);
-          
       } catch (error) {
           this.log(`Error updating note status: ${error.message}`);
-          new Notice(`⚠️ Error updating status: ${error.message}`, 3000);
+          if (this.settings.showNotifications) {
+              new Notice(`⚠️ Error updating status: ${error.message}`, 3000);
+          }
+      }
+  }
+  
+  // Method for the test button to use
+  runTest() {
+      this.log('Running test...');
+      
+      // Make sure we're using the current active board
+      this.checkForActiveKanbanBoard();
+      
+      if (!this.activeKanbanBoard) {
+          new Notice('⚠️ No active Kanban board found - open a Kanban board first', 5000);
+          return;
+      }
+      
+      // Find items in the active board
+      const items = this.activeKanbanBoard.querySelectorAll('.kanban-plugin__item');
+      const count = items.length;
+      
+      new Notice(`Found ${count} cards in active Kanban board`, 3000);
+      
+      if (count > 0) {
+          // Process the first item with a link
+          for (let i = 0; i < count; i++) {
+              const item = items[i] as HTMLElement;
+              if (item.querySelector('a.internal-link')) {
+                  new Notice(`Testing with card: "${item.textContent.substring(0, 20)}..."`, 3000);
+                  this.processKanbanItem(item);
+                  break;
+              }
+          }
       }
   }
 }
@@ -416,50 +484,52 @@ class KanbanStatusUpdaterSettingTab extends PluginSettingTab {
       
       new Setting(containerEl)
           .setName('Debug Mode')
-          .setDesc('Enable detailed logging to console')
+          .setDesc('Enable detailed logging (reduces performance)')
           .addToggle(toggle => toggle
               .setValue(this.plugin.settings.debugMode)
               .onChange(async (value) => {
                   this.plugin.settings.debugMode = value;
                   await this.plugin.saveSettings();
-                  new Notice(`Debug mode ${value ? 'enabled' : 'disabled'}`);
+                  
+                  if (value) {
+                      new Notice('Debug mode enabled - check console for logs', 3000);
+                  } else {
+                      new Notice('Debug mode disabled', 3000);
+                  }
               }));
       
       // Add a test button
       new Setting(containerEl)
           .setName('Test Plugin')
-          .setDesc('Scan for Kanban items to verify plugin is working')
+          .setDesc('Test with current Kanban board')
           .addButton(button => button
               .setButtonText('Run Test')
               .onClick(() => {
-                  new Notice('Looking for Kanban items...');
-                  const items = document.querySelectorAll('.kanban-plugin__item');
-                  new Notice(`Found ${items.length} Kanban items`);
-                  
-                  if (items.length > 0) {
-                      this.plugin.processKanbanItem(items[0] as HTMLElement);
-                  }
+                  this.plugin.runTest();
               }));
       
-      // Add troubleshooting section
-      containerEl.createEl('h3', {text: 'Troubleshooting'});
+      // Performance info
+      containerEl.createEl('h3', {text: 'Performance Optimization'});
       
       containerEl.createEl('p', {
-          text: 'If the plugin is not working:'
+          text: 'This plugin only monitors the currently active Kanban board to minimize performance impact.'
       });
       
+      // Troubleshooting section
+      containerEl.createEl('h3', {text: 'Troubleshooting'});
+      
       const list = containerEl.createEl('ul');
       
       list.createEl('li', {
-          text: 'Ensure the Kanban plugin is installed and enabled'
+          text: 'The plugin only works with the currently open Kanban board'
       });
       
       list.createEl('li', {
-          text: 'Make sure your Kanban cards contain internal links to notes'
+          text: 'Cards must contain internal links to notes'
       });
       
       list.createEl('li', {
-          text: 'Try enabling Debug Mode and check the developer console (Ctrl+Shift+I)'
+          text: 'Keep Debug Mode disabled for best performance'
       });
   }
-}
+}
\ No newline at end of file
diff --git a/styles.css b/styles.css
index 10c9ff8..4a9bd2a 100644
--- a/styles.css
+++ b/styles.css
@@ -1,25 +1,13 @@
 /* styles.css for Kanban Status Updater */
 
-/* Status bar styling */
+/* Status bar styling - minimal to ensure good performance */
 .kanban-status-updater-statusbar {
   color: var(--text-accent);
-  font-weight: bold;
-  padding: 0 10px;
-  background-color: rgba(var(--accent-rgb), 0.1);
-  border-radius: 4px;
+  font-size: 0.8em;
+  padding: 0 8px;
+  opacity: 0.8;
 }
 
-/* Notification styling */
-.notice .kanban-status-update-notice {
-  font-weight: bold;
-}
-
-.kanban-status-old-value {
-  text-decoration: line-through;
-  opacity: 0.7;
-}
-
-.kanban-status-new-value {
-  font-weight: bold;
-  color: var(--text-accent);
-}
+.kanban-status-updater-statusbar:hover {
+  opacity: 1;
+}
\ No newline at end of file