Version History

A new automated test verifies that all menu targets referenced in training lessons are within reach of the menu lookup system. The test analyzes the XAML structure to measure nesting depth and ensures no lesson tries to navigate to a menu that's too deeply nested to be opened programmatically.

Training lessons that demonstrate nested menu options will now properly open those menus during lesson playback.

Training lessons that walk through nested menu commands now properly open those menus so you can see what they're demonstrating.

Added automated test that parses the main window XAML and validates that all menu items referenced in training lessons are within reach of the menu lookup logic. This prevents future lessons from targeting menus nested too deeply to be opened during playback.

The loading screen now properly hides when you're asked to confirm a large export, making the dialog easier to see and interact with.

When exporting more than 50,000 price changes to Westlake Excel format, you'll now see the confirmation dialog asking if you want to continue. Previously this would fail silently without completing the export.

When exporting large datasets (over 50,000 records) to Westlake Excel format, you'll now see the confirmation prompt asking if you want to continue, and the export will complete successfully after you confirm.

If an error occurs during a Westlake Excel export, you'll now see an error message explaining what went wrong instead of the export appearing to do nothing.

Added defensive error handling to the auto-backup service's trigger method. When the system cannot read the backup setting due to database connectivity issues, it now logs a warning and skips the backup attempt rather than propagating the exception to calling code. This prevents unobserved task exceptions at startup and false error reports in save workflows.

If you see a message saying your store settings don't match your database, the system will guide you to confirm the correct store information before continuing. This prevents pricing data from the wrong vendor being loaded into your database.

You will no longer see "Failed to save strategy" error messages when your pricing strategies have actually saved successfully. This could happen when the database was slow to respond.

Fixed rare crashes during startup or misleading "Failed to save strategy" errors when automatic backups couldn't check their settings due to temporary database issues.

If your store was affected by the August license server issue, the system will automatically restore your correct store identity on startup.

When your store identity is validated, the system now ensures your organization settings match your actual store, not a previously incorrect one.

Database credential synchronization now preserves the About table's store identity when it contradicts incoming ApplicationSettings, rather than overwriting the database's own record. This ensures the independent evidence needed for startup validation remains intact until the user confirms the store through Store Configuration.

Warning messages in the store setup window now wrap to multiple lines so you can read the full explanation.

When the user validates and saves store credentials through Store Configuration, those values are now recorded in the About table as well as ApplicationSettings. This ensures startup validation won't re-prompt for the same identity on every launch after a legitimate store change.

Implemented automatic recovery for the specific license fallback case (Ace 33859) that affected 24 installations between February and August 2026. When this known stamped identity is detected on a database whose About table names a different vendor's store, the database's own store number is offered as a suggestion in the Store Configuration window, streamlining the correction process.

Modified the database setup wizard to skip synchronizing store identity to the About table when a vendor contradiction is detected. This preserves the database's independent record of its own identity so the startup validation can detect the mismatch and prompt the user to resolve it.

The Store Configuration window now records the user-confirmed store number and vendor in the About table after validation succeeds. This keeps the database's own identity record in sync with ApplicationSettings, preventing repeated prompts on subsequent launches after a legitimate store change.

If your store settings were accidentally changed to another company's store number, the app will now catch this at startup and ask you to confirm your correct store information before proceeding.

If a database restore fails, you'll now see the actual error message from SQL Server right away instead of waiting 30 seconds for a vague timeout message.

The "Update Cloud Demo Database" workflow now refuses to proceed if any provenance check fails, listing each specific failure reason before any backup is created. Previously, only the database name prefix was checked, which allowed customer data to be published.

Database restores now work correctly even when the backup file name doesn't match the database name inside it, preventing conflicts with your live database files.

Strategy runs on demo databases are no longer posted to the cloud analytics system. Previously, executions on demo databases (which contained real customer data until this fix) were being reported as store 99999's activity, leaking customer pricing strategies and dollar impacts.

When your store information is corrected, cloud sync settings will now automatically update to use your correct organization instead of keeping another store's settings.

Fixed the context message banner in the Store Configuration window to properly wrap long messages by replacing horizontal StackPanel with DockPanel layout. Messages explaining identity conflicts now display completely instead of being truncated.

Implemented DemoDataProvenancePolicy and DemoDataProvenanceReader to verify that demo databases are genuinely synthetic before publication. A database must pass all checks: correct naming prefix, presence of a synthetic-data marker (written only by the scrub script), no POS/server credentials, no connection strings, and no strategies imported from real stores. This was created in response to an incident where both demo databases were discovered to be real customer databases (Ace store 11325 and DIB store 3174) with only store identity changed, including plain-text SFTP passwords.

Created DemoDataProvenancePolicy and DemoDataProvenanceReader to verify that a database is provably synthetic before allowing it to be published as a demo database. The system checks four requirements: correct naming (MarginMaster_Demo_*), presence of a synthetic-data marker written only by the scrub script, no populated credential or store-identity settings, and no strategy names indicating imports from real stores (like "11325v0045-PS_imported"). All checks must pass before a database can be uploaded.

Modified DemoModeWorkflowService to run provenance verification before backing up and uploading a demo database. If verification fails, the upload is blocked and a detailed message explains which checks failed. This prevents repeat of the September 2026 incident where real customer databases (Ace store 11325 and DIB store 3174) containing plain-text SFTP passwords were published to all Demo Mode users.

Added check to prevent strategy execution analytics from demo databases being posted to the cloud fleet tracking system. Previously, strategy runs on demo databases (which contained real customer data until this fix) were reported as store 99999's executions, mixing curated demo data with fleet statistics.

Added Invoke-DemoDatabaseScrub.ps1 PowerShell script that transforms a customer database into a safe demo database by regenerating all store-specific pricing and sales values from deterministic hashed seeds, removing POS imports and credentials, clearing real-store strategy artifacts, and writing the synthetic-data marker as the final step. The script is kept outside the shipped application's embedded scripts directory.

Added PowerShell script Invoke-DemoDatabaseScrub.ps1 that transforms a customer database into a safe demo database by regenerating all store-specific pricing and sales values from deterministic hashes, removing POS imports and credentials, blanking server addresses, and writing the synthetic-data marker as the final step. The script refuses to process any database not named "MarginMaster_Demo_*" and can verify that no values match the original source table.

Added 10 unit tests that pin the exact behavior of the provenance policy, including verification that the leaked Ace demo database as-it-was would be refused on every count except the name. Tests ensure all credentials found on leaked databases remain in the checked lists.

Added test suite pinning the exact checks that failed on the leaked demo databases, ensuring every credential found on those databases (AFTPIP, AFTPUSER, AFTPPASS, MySql credentials, RSD server addresses, store contact information) remains in the checked lists. Tests verify that databases matching the leaked demos' exact state are refused on every count except the name prefix.

After running a strategy, you can now use Strategy > Show Strategy Execution Summary to bring back the results screen if you closed it. This lets you review the numbers, see which steps ran, and use the "Show Skus Not Priced" or "Show Skus That Changed" buttons without waiting for the strategy to run again.

After running a pricing strategy, you can now go to the Strategy menu and choose "Show Strategy Execution Summary" to bring back the results screen, even if you closed it. This lets you review the numbers, see which steps ran, and drill into the changes without running the strategy again. The menu option is only available after you've run a strategy since opening Margin Master.

After choosing "Show Skus NOT included in Strategy," you can now add departments, vendors, or any other selection and press Refresh to narrow down the unpriced items. The filter stays active until you clear it.

When you choose "Show Skus NOT included in Strategy," you can now add other filters like department or vendor and press Refresh to see unpriced items within that selection. The filter stays on until you clear it.

If you've turned off automatic strategy summaries in settings, the new menu command will still show the summary when you ask for it—the setting only controls whether it pops up automatically after each run.

Set Future Price, Remove Decreases, and all exports now work correctly with the No Pricing Rule filter—they'll only affect the unpriced items you're viewing.

The "Show Execution Logs" button opens the folder with detailed logs from all your strategy runs.

You can now delete the unpriced items if needed—the Delete Displayed Skus command is no longer blocked.

If you've turned off the setting that automatically shows the summary after each strategy run, the new menu command still works—it knows you're asking for it specifically.

The "No Pricing Rule" filter now shows up either as a ticked BLANK in your PS Rule box (if you have one), or as a pill you can click to turn off. Press F12 to clear it along with everything else.

If you have a PS Rule box, the filter shows as a checked "BLANK" entry you can untick. Otherwise, a "No Pricing Rule" pill appears next to your selection tabs—click it to turn off the filter.

The command is grayed out when you first open Margin Master, with a tooltip explaining it will become available after you run a strategy. It stays available for the rest of your session, even if you close and reopen the summary multiple times.

If the menu option is greyed out, hovering over it explains that you need to run a strategy first before the summary can be shown.

The "Show Execution Log" button is now "Show Execution Logs" to clarify that it opens a folder with multiple log files.

Added NoPricingRuleFilterPolicy class to define which column answers "did any step touch this SKU" (PSRuleHistory), which selection box should carry the filter, and the BLANK sentinel value. This ensures the on-screen filter, execution summary count, and Excel export always agree on what "no rule" means, preventing drift between different code paths.

Import progress messages now always show a clear store identifier instead of displaying blank spaces for certain store types.

The support log now records how long each store's POS data merge takes to complete. This allows support staff to distinguish between slow merges (normal for large stores) and truly stuck operations, since the 10-minute command timeout meant both could appear identical in logs.

Added timing and duration logging for the POS-to-store-table merge operation. With a 600-second command timeout, support logs previously couldn't distinguish between a slow merge and a stuck one. Merge completion is now logged with elapsed time, enabling faster diagnosis of import performance issues.

If you're importing a large POS file, you'll now see the import progress through "merging POS data," "rebuilding SKU index," and "finalizing store data" steps instead of the screen appearing frozen on one line.

When importing large Compass stores, the progress screen now shows "merging POS data," "rebuilding SKU index," and "finalizing store data" as separate visible steps instead of appearing frozen during the merge.

Fixed a display issue where Epicor character-based stores showed "Processing Store Data" with a blank space instead of the store identifier. The progress message now uses the same effective store key shown in the main import loop, ensuring consistent labeling throughout the import process.

Hovering over the "Show Affected Items" button now explains that you need to select a step from the list above first, even when the button is greyed out.

Clicking "Show Skus Not In Strategy" or "Show Affected Items" from the strategy summary now correctly displays only the filtered items you requested, instead of showing all price changes.

All buttons in the Strategy Execution Summary are now visible and clickable, even when the dialog is resized smaller.

The Strategy Execution Summary window now opens wider so the Close button and other action buttons all fit on one line without wrapping.

When viewing the Strategy Execution Summary, all buttons now appear on one line and are fully visible without any wrapping or clipping.

All buttons in the strategy summary dialog are now fully visible and properly arranged, with no text overlap or clipping.

When you click "Show Skus Not In Strategy" or "Show Affected Items" in the Strategy Execution Summary, the grid now displays the items you requested instead of showing all price changes.

The width calculation now accounts for the measured space requirements: approximately 925 pixels for the six buttons and 300 pixels for the checkbox column. This ensures proper layout without clipping or overlapping elements.

The dialog dimensions were measured and calculated based on actual button requirements rather than estimated, ensuring the layout remains stable and readable at the new size.

Hovering over the greyed-out "Show Affected Items" button now explains that you need to select a step first.

If your database has a generic name like "OlderMM" or still says "MarginMaster3", you can now rename it to something that identifies your store (like "DIB_10368_Woodstock_Hardware_Epicor"). Margin Master suggests the name from your store information and you can edit it. The rename keeps a backup, so nothing is lost.

The Rename Database tool now works on any of your databases, not just the default "MarginMaster3" name. It suggests a name that identifies your store and you can edit it. Your connection switches automatically when you rename the database you're using.

A red warning badge will appear in the title bar if your store number has been retired. Click it to see details and migrate to your current store number.

The migration tool now moves all your pricing rules, margins, and exceptions to the new store number automatically, not just basic settings.

The database housekeeping tools (Optimize/Shrink, Reset Database, Run Maintenance Scripts) are now easier to find: open SQL Server Tools from File > Utilities and look in its Tools menu, right alongside Rename, Migrate and Delete Database.

All database tools are now together in File > Utilities > SQL Server Tools. Look in its Tools menu for Rename, Migrate, Delete, Optimize/Shrink, Reset Database, and Run Maintenance Scripts.

The convention for building a database name from store information (`{Vendor}_{StoreNumber}_{StoreName}_{POS}`) now lives in one tested place (`DatabaseNameBuilder` in `MarginMaster.Common`) instead of three hand-maintained copies that had drifted. The builder sanitizes each part, validates names against SQL Server's reserved words and character rules, recognizes generic/timestamped names (like "MarginMaster3" or "OlderMM_20260909_160718") that identify no store, and generates unique names when the base name is already taken. This is shared by the Create New Database window, the Rename Database window, and backup file naming, so they always agree on what counts as a valid name.

GetOrganizationStoresAsync gains a forceRefresh parameter that drops the 30-day cache entry before fetching. Required for closed-store detection since a store retired last week would otherwise report as open for a month. The store identity health check uses this flag to ensure StoreStatus reflects current cloud state rather than stale cached data.

The previous implementation only matched store scope tokens followed by a pipe character (StoreNumber~3605|), causing it to miss tokens in the last position of a rule — precisely the most common shape for per-store pricing rules. Rules scoped to a single store were the most likely to be missed, leaving stores operating under retired numbers. The new StoreScopeTokenRewriter correctly handles tokens at any position including end-of-string.

Store renumbering previously used a simple string replacement (Replace("3605","10368")), which would silently corrupt any SKU, product group, cost, or margin value that happened to equal the old store number. The new token-based rewriter anchors every change to the "StoreNumber~" prefix, ensuring only actual store scope tokens are modified while leaving all pricing data untouched. Includes 17 new tests specifically guarding against distinct corruption scenarios.

The EpicorStoreMapStrategiesConverted flag was being written back as "false" instead of "true", causing the entire store number conversion to re-run on every Epicor extract. This was harmless only as long as no store number was ever reused. The flag now correctly latches after successful conversion, and the conversion process properly tracks and logs the number of rules changed.

If your organization has multiple stores, the tool will ask you to confirm which one is correct rather than guessing.

When renaming the database Margin Master is currently connected to (which is allowed), the connection is switched to the new name *before* the old database is dropped. This is required because the drop runs `SET SINGLE_USER WITH ROLLBACK IMMEDIATE`, which would otherwise kill the app's own session. The Rename Database window warns when the selected database is the active one and offers to switch the live connection after the rename succeeds.

Renaming a database now opens a window where you pick the database, see the suggested name, watch the progress, and get a clear result—no more jumping between message boxes.

Before changing your store number, you'll see a preview of exactly what data will be moved, so you can confirm the migration is safe.

The "Rename Current Database" menu item is now always available when you have a database open, regardless of its current name.

`IInstanceMigrationService.GetStoreIdentityAsync` reads vendor, store number, store name, and POS system directly from a database's `dbo.ApplicationSettings` table—independent of the running application's settings—so a name can be suggested for any Margin Master database on any instance, even one the app isn't connected to. This prevents the old problem where a rename suggestion depended on the *current* store's settings rather than the database's own identity.

Database renaming and instance migration now share a common `CopyDatabaseAsync` service that handles backup + RESTORE-to-new-location + optional drop-source. This generalizes `InstanceMigrationService` so a migration is a copy with the name unchanged, while a rename is a copy to the same server under a new name. The service derives new physical file names from `RESTORE FILELISTONLY` rather than string-replacing the old database name inside the old file name, fixing cases where the .mdf was never named after the database in the first place (the MM-1458 backup was exactly that: database "OlderMM", logical names "MarginMaster2", physical files "DIB_3605_Woodstock_Hardware_Epicor"). This deletes the old `DatabaseRenameService`, whose string-replacement assumption was a no-op whenever the file and database names didn't match.

A new `DatabaseNameBuilder` class centralizes the database naming convention ({Vendor}_{StoreNumber}_{StoreName}_{POS}), validation rules, uniqueness logic, and generic-name detection. This logic was previously maintained in three separate hand-written copies (Create New Database, the old rename tool, and backup file naming) that had diverged over time—MM-1458 was the cost of that drift, where a Do-it Best store ran on a database called "OlderMM" and submitted backups that couldn't be identified. The Create New Database window, Rename Database window, and backup services now all use this shared implementation.

Store number comparison logic (leading zero handling) has been consolidated into StoreScopeTokenRewriter.NormalizeStoreNumber in MarginMaster.Common, shared by both WPF migration and DataImport. StoreIdentityRepairPolicy now delegates to this single implementation, eliminating the risk of half-applied renumbering caused by inconsistent "is this the same store" checks across different code paths.

`InstanceMigrationService.CopyDatabaseAsync` is the new general form behind both migrations and renames: it copies a database from one server+name to another server+name via backup and restore, optionally dropping the source afterward. A rename is this operation with the server unchanged and drop-source enabled. The restore step now relocates the physical .mdf/.ldf files to match the destination database name (via RESTORE FILELISTONLY and per-file MOVE clauses), so a renamed database gets files named after its new identity rather than keeping the old MarginMaster3.mdf forever.

The sample training lessons for "menu-bar" and "reset-stale-data" have been re-rendered to reflect the menu structure changes (the rename tool now being available for all databases, and the housekeeping tools moving to SQL Server Tools). The SQL Server Setup Window documentation has been updated to describe the new Tools menu and the Rename Database window.

Enhanced the AutoUpdateService.DownloadUpdatesInBackgroundAsync method to accept a progress callback parameter, allowing callers to receive percentage updates during the download. Progress events are marshaled from background threads to the UI dispatcher, with duplicate percentage values filtered to avoid unnecessary UI updates.

You'll now see a blue "Installing update…" badge with a percentage in the title bar while updates download in the background. You can keep working normally—nothing restarts until the green "Update Ready" button appears.

The blue "Update Available" badge now means a download failed and clicking it will retry—it's not shown during active downloads anymore.

Added update download progress tracking to three code paths: the automatic update timer task (ExecuteAutoUpdateTaskSafeAsync), the snoozed update pill surfacing (SurfaceSnoozedUpdatePillAsync), and manual update checks (CheckForUpdatesAsync). Each path now shows the downloading pill with percentage updates and properly clears it in a finally block to prevent stuck UI state if downloads fail.

A new help document is available for your IT staff that explains which folders and files to exclude from antivirus scanning to prevent update and startup problems.

If the update server doesn't respond during startup, Margin Master will now give up after a reasonable time and open normally instead of staying stuck on the splash screen. The automatic hourly check will retry the update in the background.

Introduced DownloadStallWatch, a state machine that monitors download progress signals to distinguish between slow-but-working transfers and genuinely stalled connections. It tracks consecutive seconds without progress rather than total elapsed time, ensuring slow stores can still complete updates while preventing indefinitely stalled transfers from blocking startup. The 90-second threshold was chosen because Velopack's progress callback fires frequently, so prolonged silence indicates bytes have stopped arriving. Comprehensive unit tests validate both thresholds—never abandoning working downloads and always abandoning dead ones.

Created StartupUpdateGuard to encapsulate all timeout logic for startup-path update operations, using TaskTimeoutHelper to race operations against their timeouts and DownloadStallWatch for progress monitoring. The service separates timeout handling from update logic and makes the decision-making testable in isolation. When operations are abandoned, they're allowed to finish or die in the background since Velopack writes to temporary files that the next attempt purges.

Modified DownloadUpdatesInBackgroundAsync to accept an optional progress callback and pass it through to the underlying DownloadUpdatesAsync method. All three silent download call sites (periodic timer check, startup snoozed-update path, and background download after check) now light the pill with percent-complete updates. Each caller clears the pill in a finally block so failed downloads cannot strand the indicator, and SetUpdateDownloadingPill swallows dispatcher errors to prevent masking real exceptions.

The blue "Update Available" pill now correctly means a download failed and needs to be retried, while the new "Installing update…" pill shows when a download is actively running.

When Margin Master downloads an update in the background, you'll now see a blue "Installing update…" pill in the title bar showing progress percentage. This lets you know the app is working on fetching a new version, not just running slowly.

Updated banners-and-badges.md and update-modes.md to document the new "Installing update…" pill, clarifying the distinction between actively downloading (blue pulsing pill with percent), download complete and ready to apply (green "Update Ready" pill), and download failed (blue "Update Available" pill). Added search keywords for users looking to understand why Margin Master is downloading or showing update progress.

Click "Show Skus Not In Strategy" on the summary screen to see the items your strategy didn't select—no need to hunt through the menus.

Export the full not-priced list to Excel with a Reason column that tells you what to fix for each item. The file isn't limited by your display records setting, so you get the complete list.

The execution summary now has a "Show Skus Not In Strategy" button that opens the list of items your strategy didn't select, so you can go straight from the number to the actual items.

You can now export the complete list of not-priced items to Excel from the execution summary or the Strategy menu. The export includes a Reason column explaining why each item was left alone, and it's not limited by your maximum display records setting.

The summary now says clearly that unpriced items are not an error—your strategy just didn't select them. It shows how many had no cost versus how many weren't selected by any step.

The zone override field now has a clear button to remove overrides, and won't let you save a zone number that doesn't exist in the pricing data.

The "Show Skus NOT included in Strategy" menu item is now disabled until you've run a strategy at least once. If the list is empty after a run, you'll see a message explaining that every item was priced.

After each sync, the system automatically fixes any stores with invalid zone overrides and reports which stores were corrected in the import log.

Zone pricing operations now log when a store's zone override points to a zone with no data, making it much easier to diagnose pricing issues. Previously these failures were completely silent.

The execution summary now explains that "Items not priced" is normal, not an error—it just means your strategy's steps didn't select those items. The line shows how many were skipped because no step selected them versus how many have no cost.

If a store somehow ends up with a zone that has no pricing data, you'll now see a clear warning in the import results instead of the problem being silent.

The "Show Skus NOT included in Strategy" menu is greyed out until you've run a strategy—before that, nothing has been priced yet so the list would be meaningless.

If the not-in-strategy screen is empty, you'll see a message confirming that every item was covered—not just a blank grid.

The detailed strategy log file now says "ITEMS LEFT WITHOUT A NEW PRICE: N" instead of "SKUS WITH NO PRICING RULE," and explains "Not an error—the strategy's steps did not select these items." It logs the NoRuleCount separately ("N were touched by no step at all (PSRuleHistory is empty). This is what Strategy > Show Skus NOT included in Strategy loads.") so a support reader can reconcile the grid's row count against the file.

When entering a zone override for a store, Margin Master now checks that the zone number you typed is valid before saving it. If the zone doesn't exist, you'll see an error message and the value won't be saved.

Stores with invalid zone overrides will now show an error when you try to enter them, and the system will automatically fix any existing invalid overrides during import.

If you try to enter a zone number that doesn't exist in your vendor catalog, the system will now warn you and prevent the save. You can also click the X button to clear a zone override completely.

The "Show Skus NOT included in Strategy" screen now shows the correct list of items your strategy didn't select. Previously, if your strategy had a catch-all step, some items were missing from the list.

Stores that previously had broken zone overrides (showing zero or invalid zone numbers) will automatically have those bad values cleared, restoring correct zone pricing.

If a store has a zone override set to a zone number that doesn't have any pricing data, the system will automatically remove that override during sync and let the store use its assigned zone. You'll see a note in the import results if this happens.

Stores with invalid zone numbers stored from before this fix will now correctly use their Ace-assigned zones instead of pricing at "zone 0."

If a store's zone has no pricing data, you'll now see a clear warning in the import report instead of pricing silently being skipped.

The "Show Skus NOT included in Strategy" list now shows all items no step touched, even when your strategy has a catch-all step—it was undercounting before.

Updated StoreManagerInfo.EffectiveZone to treat zero or negative zone values as "not set" and fall through to the assigned zone, then to national zone 99999. Previously a stored zero was honored as a valid override, resolving to pricing zone "0" which matched no records.

When you set maximum display records to "Unlimited," grids will now actually load all records instead of stopping after just one row.

Setting Maximum Display Records to "Unlimited" now actually loads all records instead of stopping at one.

You can now click the X button in the Zone Override box to remove an override and let the store use its regular Ace-assigned zone. Before, there was no way to clear an override once entered.

The execution log's unpriced section now reports the NoRule subset separately from the total, labels both populations by what they mean, and names the menu path that reaches them, so a support reader can reconcile the grid's row count against the file.

Added "Show Skus Not In Strategy" and "Export Not Priced" buttons to StrategyExecutionSummaryView.xaml, shown only when HasUnpriced is true. The view model raises their CanExecuteChanged when HasUnpriced changes via POCO convention. Both buttons set request flags (ShowNotInStrategyRequested, ExportNotPricedRequested) and close the dialog so the grid or export runs without a modal in the way, matching the "Show Affected Items" pattern.

UnpricedSkuTableCount gained a NoRule field—the subset of unpriced rows with an empty PSRuleHistory trail. This is what "Show Skus NOT included in Strategy" loads, reported separately from the total unpriced count (which also includes rows a step claimed but could not price) so the summary can quote the number the grid will actually match.

The execution summary report, the grid loader, and the export were three hand-written WHERE clauses selecting the "not priced" population, and they had already drifted. They are now RoundingSql.NoRuleTouchedPredicate(), UnpricedPredicate(), and UnpricedReasonSql(), interpolated by every reader, so the number the summary quotes and the rows the grid and export load cannot disagree. UnpricedSkuReport gains NoRuleCount so the summary can quote the subset the menu item actually loads, separately from the unpriced total.

Added RoundingSql.NoRuleTouchedPredicate(), UnpricedPredicate(safeCostSql), and UnpricedReasonSql(safeCostSql) helpers. The unpriced report, the grid loader, the export, and the execution log all call the same expressions, so the counts can never drift. Comprehensive tests in NoRuleTouchedPredicateTests, UnpricedPredicateTests, and UnpricedReasonSqlTests lock the predicates' shape and their relationship (no-rule is a strict subset of unpriced; the predicates are complements across the main table).

Documented the reworded "Items not priced" line, the new summary buttons, why the menu item is greyed out before a run, the export format and Reason column values, and the distinction between the full unpriced total and the no-rule subset. Added three common questions covering the rewording, the count difference, and how to get the list into Excel.

If you see an empty import file list, you'll now see a message explaining why and how to fix your POS system settings.

Large MySQL Compass inventory imports (10,000+ items) are now processed in smaller batches to prevent timeouts.

Inventory writes are now split into batches of 5,000 items with 100ms pauses between batches, matching the proven approach used for Epicor imports. This prevents large imports from being blocked by other database activity and exceeding timeout limits. Previously, all items were written in a single uninterrupted stream which could be blocked past the timeout threshold on busy servers.

Wrapped the BulkMergeAsync call with SqlTransientRetry to handle command timeouts (-2), which are typically caused by momentary database blocking. Since the merge operation uses the primary key, re-running is safe. This prevents one-off timeout failures from aborting the entire import.

Changed the severity of missing import layout messages from Error to Warning, since this is a configuration condition rather than a defect. These warnings are now reported through the store configuration issue collector to notify the appropriate person, while keeping the error dashboard clear of configuration-related messages.

If a MySQL Compass inventory import fails repeatedly on the same batch of items, you'll now see an error message after 3 attempts instead of the application appearing frozen.

If a Compass inventory import encounters repeated database errors, you'll now see a clear error message instead of the import hanging indefinitely.

If your POS system type isn't supported, the Import Manager now shows a message explaining why no files appear instead of just showing an empty list.

Fixed a memoization bug where failed POS type lookups were never cached, causing the same error to be logged repeatedly. Store 1918 generated 23 identical error reports in 15 minutes by reopening the import dialog. The lookup result is now cached per service instance regardless of success or failure.

Fixed an issue where the system logged the same "no import layout" error up to 23 times when checking import files for a POS type without a layout. The system now checks once per session and reports configuration issues through the proper channel instead of flooding error logs. This particularly affected stores on POS systems like Spruce that don't yet have import layouts.

Switched to non-MARS (Multiple Active Result Sets) connection strings for MySQL Compass bulk writes to prevent connection interleaving issues. This resolves timeout failures that occurred when bulk copy operations competed with other active queries on the same connection, which was the root cause of failures at specific high-volume stores.

Fixed an issue where listing import files for a POS type would create empty directories in the application folder even when no layout existed for that POS system. These orphaned folders accumulated during updates. The system now only reads existing layout directories without creating new ones.

Changed from ActiveConnectionString to ActiveConnectionStringNoMARS to match the convention used by sibling dw_item imports. MARS (Multiple Active Result Sets) was causing the bulk copy to interleave with other database reads on the same connection, contributing to batch timeout failures at store 17201.

The system no longer attempts to load an import layout when the POS type is "Unknown", which is the sentinel value for "not configured yet". This eliminates unnecessary lookups and prevents logging errors during application startup before store settings finish loading.

Fixed MappingFilesForPOS to return an empty list when the layout folder doesn't exist instead of creating it. Previously, this created empty Unknown\ and Spruce\ directories in the Velopack "current" folder for any store whose POS had no layout, which were then orphaned after updates.

If a MySQL Compass import fails repeatedly, you'll now see a clear error message explaining what happened instead of a progress bar that never completes.

Added log entry "Periodic update check armed — next check in {Interval}" when the update timer starts, making it possible to verify from customer logs whether the checker is alive. Previously it was impossible to distinguish between "checked and found nothing" and "never armed at all."

Margin Master will now correctly check for and download updates every hour while running, ensuring you get bug fixes and improvements as soon as they're available instead of waiting until you restart the app.

StopAutoUpdateTimer now properly disposes the cancellation token source and clears all task references. The run loop re-reads the timer field each iteration to handle mid-loop disposal or replacement, preventing potential race conditions when updates are applied or timers are restarted.

Added logging when the periodic update checker is armed, including the configured check interval. This makes it possible to verify from customer logs whether the background checker is running, distinguishing between "checked and found nothing" versus "never started checking" scenarios.

Fixed a defect (MM-1454) where the automatic update checker would not activate when the application was launched normally. The issue was caused by pre-creating a timer object in the constructor without a consumer task, which made the startup guard incorrectly believe a checker was already running. The guard now properly tests whether the background check task is active, ensuring updates are discovered automatically every hour rather than requiring a manual restart to pick them up.

Enhanced cleanup of update checker resources to properly dispose of cancellation tokens and clear background task references. This ensures the checker's running state is accurately reflected and prevents resource leaks during timer restarts.

If you use Azure SQL to host your Margin Master database, optimization now runs faster and generates less transaction log activity. You won't be charged for larger backups caused by unnecessary shrink operations.

On Azure SQL, Margin Master no longer runs automatic database optimization at startup, preventing unnecessary delays when opening the application.

When you run Optimize/Shrink Database on Azure SQL, the dialog clearly explains that the shrink step will be skipped and asks if you want to rebuild indexes and update statistics instead.

The "Optimize Database Indexes" command now reports "shrink skipped: Azure SQL" in its completion summary when running against an Azure SQL database, making it clear that the shrink step was intentionally omitted rather than failed.

If you use Azure SQL, the Shrink Log Files option will not appear in the Run Maintenance Scripts menu since it doesn't apply to cloud-hosted databases.

New DatabaseOptimizationPolicyTests pin the Azure SQL detection and shrink-skip behavior with comprehensive unit tests covering Azure SQL Database, Azure SQL Managed Instance, on-premises SQL Server editions, and failed version detection scenarios. The tests ensure that a failed version lookup always preserves on-premises behavior.

The SQL Optimization documentation now includes a dedicated "Azure SQL" section explaining the shrink skip behavior, documents the automatic daily optimization pass (previously undocumented), and corrects the step order to reflect that shrinking happens before index rebuild (a code change from 2026-08-20).

If your "Last Import" date doesn't match the import history in the grid below it, you'll now see a warning explaining the discrepancy and suggesting you import again.

The Data Aging screen now warns you when the POS import date and import history don't match, just like it does for vendor syncs.

Warning messages on the Data Aging screen now say when Margin Master couldn't confirm a sync result, rather than claiming your data didn't update when it may have.

Warning messages on the Data Aging screen now explain that your catalog may already be up-to-date even when dates disagree, rather than claiming the sync failed.

The "Last Synced" date on the Data Aging screen will no longer move forward unless your vendor catalog data actually updated or was confirmed current.

The "Last Synced" date on the Data Aging screen will no longer move forward after a sync that didn't actually run any tables.

If a sync merges your data but can't record the result, you'll now see a notification explaining that your catalog is up to date but the history won't show it until the next successful sync.

If a vendor sync finds no changes but some tables failed, the date will no longer incorrectly advance, preventing stale data from appearing up-to-date.

If vendor data syncs successfully but cannot be recorded in the history, you'll see a notification explaining that your data is current even though the sync history looks out of date.

Created VendorSyncOutcomePlannerTests with 7 test cases pinning the rule for when a sync should update the "Last Synced" date, and DivergenceMessageWordingTests that reads the view model source to verify the warning messages never claim the sync failed to update data when only the bookkeeping failed. The tests document the actual store incidents (5645 and 554) that led to this fix.

Created VendorSyncOutcomePlanner as a pure, tested function to decide whether a sync result should stamp the "Last Synced" date. Includes 169 lines of unit tests covering the empty result, partial success, and "already current" scenarios that previously produced incorrect stamps.

Added ExportPath and ImportPath properties to CostBreakViewModel that provide initial directory paths for file dialogs, resolved through the application settings service. These properties ensure file dialogs open to the user's preferred locations.

You can now use the Fixed Price checkbox in cost break levels—it will correctly display existing settings and save your changes. The Fixed Price and Margin % fields now appear and disappear as expected based on the toggle.

The Cost Break screen will now load cleanly without internal errors.

When you right-click on a cost break row, the menu options now correctly show the level number (e.g., "Delete Cost Break Level #3" instead of "Delete Cost Break Level #").

The Export menu in the Cost Break screen no longer shows a non-functional Import option.

The Rebuild button beside Break Type and Break Points now works—click it to apply your changes when auto-rebuild is turned off.

The Rebuild button in the Cost Break screen now works correctly to recalculate your cost break levels after changing Break Type or Break Points.

When importing or exporting cost break models, the file browser now opens to your configured default import/export folder instead of a random location.

Removed a hidden "Set Default" button and an "Import Cost Break Models" menu item that were bound to commands that never existed. Both were carried over from other screens and could never work. Left comments documenting what would be needed to restore them if the features are implemented in the future.

The mechanism that snaps the plus/minus units selector back to "0" after rejecting a "Rounding Points" choice now uses a simpler, more reliable approach. Instead of managing timer lifecycle, the reset is scheduled as a deferred UI operation that runs once the combo box selection update has completed.

The Future Price panel's plus/minus units reset now properly executes on the UI thread using the WPF Dispatcher. This eliminates potential cross-thread exceptions that could occur when the old timer-based approach modified UI-bound properties from background threads.

The Cost Break screen will no longer crash when you edit price levels rapidly or while calculations are running in the background.

The Cost Break dialog will no longer crash when you quickly edit margin targets or cost boundaries.

The Future Price panel's plus/minus units selector was creating a new background timer on every selection change without properly disposing of previous timers. Each abandoned timer continued firing every 100ms for the entire application session, writing to UI-bound properties from background threads. This has been replaced with a single deferred dispatcher call that properly executes once on the UI thread with no lingering state.

Fixed a critical memory leak where the Future Price panel created a new System.Timers.Timer every time the user attempted to select "Rounding Points" in the plus/minus units dropdown. Each abandoned timer would continue firing every 100 milliseconds for the life of the application, gradually degrading performance. The reset mechanism has been replaced with a single deferred dispatcher call that safely resets the selection without leaking resources.

When working with Cost Breaks, the price boundaries between levels will now stay exactly where you set them instead of drifting by one cent during automatic recalculations.

Cost Break pricing boundaries will now stay exactly where you set them instead of drifting slightly when the grid updates.

Closing a Cost Break window now fully releases system resources, improving overall application performance especially after opening and closing the dialog multiple times.

Closing the Cost Break dialog will no longer leave background processes running, improving overall application performance.

Replaced System.Timers.Timer with DispatcherTimer throughout the Cost Break dialog to ensure all timer callbacks execute on the UI thread, eliminating threading hazards and making the dialog more stable during user interaction.

Click "Fix This Now" when you see the settings folder warning—Windows will ask permission, then Margin Master fixes it automatically and tells you to restart.

The settings warning now shows exactly which files are blocked and gives you a "Copy Details" button to send the fix command to your IT department if you need help.

Added comprehensive help page at marginmaster.com/documents/support/settings-folder-permissions covering what the alert means, how to use the Fix This Now button, the manual icacls command for administrators, why the problem happens, and common questions. The repair dialog links directly to this page.

Old files left behind by previous Margin Master versions won't trigger the "Cannot Save Settings" warning anymore—only files the app actually needs will cause an alert.

When the settings folder alert appears, click "Fix This Now" and choose "Yes" at the Windows prompt — Margin Master will grant the permission and tell you to restart. If you'd rather have your IT department handle it, "Copy Details" gives them everything they need.

The publish workflow now automatically downloads and re-indexes any packages within the retention window that are missing from the remote feed, allowing the feed to repair itself if entries are lost. This ensures the delta chain remains complete even if previous publishes had issues.

You'll only see the settings folder alert when a file Margin Master actually uses is blocked — old files left behind from previous versions won't trigger it anymore.

Package versions are now compared as semantic versions rather than strings, so version 2026.1001.x correctly ranks above 2026.903.x. Previously, string comparison could cause incorrect packages to be retained or pruned from the feed.

Revised the "startup-stuck" training lesson audio and script to describe the new Fix This Now button and clarify that only files Margin Master uses raise the alert, not legacy leftovers.

The release feed merge step was silently failing because the remote feed backup was stored in a directory that the packaging tool clears on each run. This caused 34 of 37 stores updating from one version to the next to download the full 175 MB package instead of a much smaller delta. The backup is now saved outside the cleared directory, and the build will fail loudly if the merge cannot complete, preventing silent degradation.

The Azure blob cleanup step was silently failing due to an invalid command-line flag. Cleanup is now feed-driven: only packages not referenced by the uploaded feed are deleted, and failures are reported rather than swallowed.

If you close the settings warning without fixing it, a red "Settings Cannot Be Saved" notice stays in the title bar—click it to bring the fix button back.

If the settings folder is blocked, a red "Settings Cannot Be Saved" marker stays in the title bar at the top of the window until you fix it — click it to bring up the repair dialog again.

The Velopack packaging CLI is now pinned to match the exact version of the Velopack library shipped in the application, preventing version mismatches that can break delta patching. Bumping the library version in the central package configuration now automatically updates the CLI version.

Added docs/marginmaster/support/settings-folder-permissions.md (Part VIII, Chapter 20) explaining what the settings folder is, why Windows blocks it, how Fix This Now works, what to do if it fails, and the manual icacls commands for IT departments. The Data Aging page gained clarification about dash values in Last Update columns (normal for POS systems without per-row timestamps) and why both banners appear after extended downtime. The startup lesson's audio for step 4 re-rendered to describe the new button workflow instead of "ask your administrator."

Modified GetRoundingScheme and GetRoundingSchemeAsync to order results by ID, ensuring consistent behavior when multiple header rows exist during the brief window before consolidation runs. This prevents non-deterministic failures where the "wrong" duplicate might be selected.

Created 232 lines of automated tests covering multiple duplicate header scenarios: trailing space twins, case-insensitive duplicates, empty survivors receiving another header's rows, leading space twins, and schemes with different pricing tables. Tests validate that consolidation preserves all pricing bands, uses the lowest ID as the survivor, and properly trims scheme names.

Modified RoundingScheme lookups to explicitly order by ID when multiple headers might exist. This ensures consistent behavior during the transition period when duplicates are being discovered and consolidated.

If your store had a rounding scheme that stopped working after an update, it will now be automatically repaired when Margin Master starts.

If you had rounding schemes that appeared empty after updates, this fix ensures all pricing bands are preserved when duplicate scheme names are consolidated.

Updated technical documentation to correctly attribute the Fremont store's "1075 duplicate group(s), 2 header row(s), 1075 generated levels" error to duplicate RoundingScheme headers rather than the point table generator stall fixed in PR #1409. Added diagnostic guidance: when duplicates equal generated levels and header row count exceeds one, the cause is duplicate headers, not the generator.

Schemes whose headers were just consolidated now skip checksum validation and force a full regeneration. The stored checksum describes the pre-consolidation split table, so merged details must be regenerated under the surviving ID before the system can trust them.

Fixed a nullable reference warning in TrainingPlayerViewModel by reading the current step once instead of repeatedly dereferencing it. Corrected a column name reference in the download stats SQL query from "StoreName" to "Name" to match the Stores table schema.

Created six test cases covering trailing space twins, empty survivors receiving merged rows, case-insensitive collisions, no-collision scenarios, leading space handling, and triplet consolidation. Tests use throwaway databases and skip gracefully when the test server is unreachable.

Multiple simultaneous reconnection events (from file watchers and explicit callers) are now properly coordinated. When a reload is already in progress, new requests join the existing operation and queue one final pass to load the latest state. The returned task completes only after all queued reloads finish, ensuring consumers never read partial or cleared settings during the reload process.

Database restore operations will no longer lose your saved column views, license registration, or other custom settings.

When browsing training lessons, you can now click "Read the narration" to see exactly what the lesson will say at each step before you start it. This works with the new narration search—find a lesson by what it says, then read what it says.

Click "Read the narration" in the lesson details to see the full script that plays during each step, making it easier to preview lessons before starting them.

Put quotes around multiple words to search for them as an exact phrase. For example, "price change" will only find lessons containing those two words together in that order.

When searching for training lessons, you can now type any words that appear in the lesson's narration or instructions, not just the title. For example, searching for "price endings" will find lessons that mention price endings in their steps, even if the title doesn't include those words. Use quotes around multiple words like "zone pricing" to find that exact phrase.

You can now search for lessons using any word or phrase from the tutorial narration, not just the lesson title. For example, searching for "price endings" will find the Rounding Editor lesson even though that phrase only appears in the spoken narration.

When you open Margin Master after a background update, the title bar badge now tells you exactly what was updated—for example, "Vendor Data updated 3 hours ago" or "Vendor + Epicor Data updated 2 hours ago"—instead of the vague "Data updated" message.

When the background service updates your data, the badge now tells you exactly what was refreshed—Vendor catalogs, your POS inventory, or both—so you know which data is current.

If the background service checked for updates but everything was already current, the badge now says "Data checked... already current" instead of misleadingly saying data was "updated."

If the background service checks and finds your data is already up to date, the badge now says "already current" instead of claiming it updated something.

Restructured the "What you will do" section header to accommodate the script toggle button on the right side while maintaining the section title on the left. The toggle includes a tooltip explaining its purpose.

The "data updated" badge now only appears when pricing or catalog data was actually refreshed, not when the app itself was updated.

The search box now shows helpful instructions explaining you can search lesson content and use quotes for exact phrases.

The step list in the lesson detail pane now shows both the numbered step title and optional narration text. When the script view is enabled, narration appears indented and italicized beneath each step. Series headings continue to show only part titles without narration.

Each lesson step now shows its spoken narration text beneath the step title when narration view is turned on.

The search box placeholder now reads "Search titles and narration — use 'quotes' for phrases" to inform users about the enhanced search capabilities and quoted phrase syntax.

Added a new SidesRefreshed column to the BackgroundJobStatus table that records whether each run refreshed vendor data, POS data, both, or neither. The field is nullable to support backward compatibility with older status records, which fall back to interpreting the job type.

The BackgroundJobStatus table gains a nullable SidesRefreshed column to record which data sources each run touched. The schema migration is idempotent and handles rows written before this feature shipped by falling back to the job type.

Added a pure static search engine (LessonSearch class) with methods for parsing search terms, matching text against terms, and building searchable text from lesson content. Includes comprehensive unit tests covering term parsing, AND semantics, phrase matching, and cross-field search behavior. The engine ensures phrases never match across field boundaries (fields are newline-separated).

Introduced BackgroundRunSides as a central vocabulary for recording and interpreting which data sources a background run refreshed, with unit test coverage ensuring the composition and display logic remain consistent.

Added unit tests covering term parsing (bare words vs. quoted phrases), match logic (AND semantics, case-insensitivity, phrase ordering), and searchable text construction (including narration content). Tests verify that phrases cannot match across field boundaries and that empty queries disable filtering.

Refactored the StoreManagerInfo ordinal repair logic from StoreManagerViewModel into StoreManagerInfoWriter as a reusable method, following the MM-1368 headless pattern. The Store Manager window now delegates to this shared implementation, eliminating code duplication and enabling the repair to run in multiple contexts.

Added unit tests that verify the repair logic is safe to run repeatedly (idempotent), never resurrects invalid sentinel values as literal store numbers, always clears corruption markers, and correctly skips Epicor databases where the affected field serves a legitimate purpose.

If your store has multiple yards and items were pricing incorrectly at $19.99 when they should be $26.99 (or similar zone-based price differences), this is now fixed automatically.

If your store was pricing items at the wrong zone, zone pricing will now automatically use your correct assigned zone after the next sync or import.

Moved the char-ordinal repair SQL statement from StoreManagerViewModel to StoreManagerInfoWriter so both the Store Manager window and the headless zone pricing pipeline can share the same validated repair logic, reducing code duplication and maintenance burden.

Added StoreManagerOrdinalRepairTests with five test cases that verify the repair logic: restores correct POS store numbers, never creates invalid "99999" store numbers, always clears corruption markers, only touches corrupted rows (idempotent), stamps update timestamps, and safely no-ops for Epicor systems where the data structure is legitimate.

Seven new guides are now available in Training Mode (lessons 1020-1022, 2023-2025, and 3005) that walk you through multi-computer setup, adding catalog items, importing spreadsheets, cost break pricing, manual price entry, price sensitivity codes, and Ace MAP pricing.

The Excel import help now correctly explains that importing custom spreadsheets is an advanced feature best done with support assistance the first time.

The MAP and IMAP pricing documentation now accurately describes which columns appear automatically and how they're labeled in the Future Price panel.

Updated price sensitivity code documentation to clarify that Do-It-Best's OneClick Statistics shows awareness codes A through E plus a "Not Assigned (X)" row, and corrected the Add from Catalog menu caption to match the actual implementation.

Rendered 39 audio narration clips for the seven new training lessons and guides using text-to-speech synthesis, enabling the interactive walkthrough experience with voice guidance.

Turn on Training Mode from the Help menu and type the lesson number (4006 for BisTrack, 4007 for Paladin, 4009 for RockSolid, or 4008 for Transact) to learn how to import your store data step by step.

If Margin Master gets stuck while starting up, the new lesson explains what each startup message means and how to fix it.

If your columns look different after an update, the new lesson shows how to restore them and how to prevent changes in the future.

The new lesson explains how you get on beta testing, how to tell if you're on it, and how you automatically return to regular updates.

If the same price changes keep coming back week after week, the new lesson explains why it happens and how to stop it.

The new lesson shows how to work on just one department at a time or apply changes to only specific items.

More common questions now have step-by-step lessons available in Training Mode.

Added "Walk through it in the app" callout boxes to 8 handbook pages (edit-columns.md, printing-and-exporting.md, selection-boxes.md, update-modes.md, and four POS import pages) directing readers to the corresponding interactive lessons with their lesson numbers.

Automated backlog tracking now shows 93 completed lessons (up from 64), 91 open tasks (down from 122), covering 29 newly-addressed support topics including stuck logins, column resets, beta mode, duplicate price changes, and POS-specific imports.

Added logic to differentiate between the system drive root (typically C:\, which standard users cannot write to) and other drive roots like mapped network drives. Bare drive letters are stored with trailing backslashes to ensure Windows interprets them as drive roots rather than current directories on those drives.

Large store imports on slower servers are now much less likely to timeout during the final data processing steps.

Multi-store imports now clear error state between each store so that one store's processing failure does not incorrectly trigger data-loss protection for subsequent stores in the batch.

The SQL service now records exceptions from failed ExecuteNonQueryAsync calls so that downstream code can distinguish between "zero rows affected" and "operation failed with timeout/error," enabling more accurate diagnostics in import processing.

If you export files to a mapped drive like M:\, that path will now stay saved in your settings instead of changing back to C:\MarginMaster every time.

If you configure a mapped network drive (like M:\) as your export folder, Margin Master will now remember and use that location instead of switching it back to C:\MarginMaster.

If a Paladin multi-store import is interrupted by a database timeout, you'll now see a clear error message and your store's existing data will remain unchanged, instead of silently losing all inventory data for that store.

If your database runs slowly during a multi-store import, the import will now wait long enough to complete successfully instead of accidentally deleting your store's data.

Non-system drive roots are now canonicalized with a trailing separator (M:\ instead of M:) because Windows interprets "M:" as "current directory on M:" rather than the root. This ensures the configured path always points to the intended root directory.

Import error messages now correctly identify which store failed in multi-store imports, making it easier to diagnose and re-run specific stores.

The new guide walks you through how Margin Master checks for updates automatically, what to do when the Update Available badge appears, and how to check for updates yourself from the Help menu whenever you want.

When you open Training Mode, you'll find a new guide under Getting Started that explains how updates work, what to do when you see the blue Update Available badge, and how to check for updates yourself using the Help menu.

When setting up Margin Master on a new computer, three new training guides show exactly what to do: first back up your old database, then install on the new PC, then restore the backup.

Training Mode now walks you through moving Margin Master to a new computer step-by-step, including backing up your data, installing the software, and getting your database back.

The Help menu now includes ten new step-by-step guides covering common tasks like recovering from a failed update, understanding why price change counts differ between screens, creating pricing rules, troubleshooting unexpected strategy results, and connecting to your Epicor system.

The What's New dialog now offers ten new step-by-step training guides covering common tasks like setting up Epicor connections, troubleshooting pricing strategies, understanding price change counts, and recovering from failed updates—each with audio narration and on-screen guidance.

The Help menu's Lessons & Guides now includes 11 new walkthroughs covering common tasks like setting up a new computer, building pricing strategies, fixing frozen programs, and moving your work to another machine. Each guide narrates the steps and highlights what to click.

You can now turn on Training / Guide Mode from the Help menu to access step-by-step guides that walk you through tasks right inside Margin Master.

Three new guides teach the complete price change process: running the strategy, sending the file and printing tags, then finalizing in your point-of-sale system.

New guides show the complete price change process from executing your strategy through printing tags and finalizing in your POS.

Training guides now appear based on your store's configuration—for example, Ace Hardware stores see zone pricing guides, while Epicor users see Eagle-specific connection instructions.

Learn your regular routine: update vendor data from the cloud, then import your point-of-sale inventory, and understand why the same record count each time is normal.

A new guide explains how to clear out old SKUs or vendor data that won't go away, starting with the gentlest fix and working up to deeper resets.

A new guide explains how to clear stale SKUs or fix pricing data that won't update, from gentle fixes to deeper resets.

Get a roadmap of Margin Master's pricing setup: which features do what, and which lessons explain each part.

Troubleshoot tag printing: learn why unchanged items got tags, how to pick the right printer, and how to reprint missed labels without wasting sheets.

Load competitor prices from a spreadsheet into your grid's Comp columns to compare your pricing against other stores.

Do-it Best stores: learn how to update your vendor catalog and pricing from the cloud, and what to do if something doesn't sync.

Paladin users: send your price changes to Paladin by exporting the text file it imports, then finish the price change in Paladin.

RockSolid users: Margin Master writes price changes directly into RockSolid's import table — learn the paths that matter and how to finish the change.

Propello users: import your inventory directly from Propello's cloud, or set up the connection if you haven't already.

If Margin Master can't reach its database after a Windows update, learn how to restart the SQL Server service and get back to work.

Fix a missing or extra store in your store list by re-importing POS data or adjusting the Exclude setting in Store Manager.

Learn how live support sessions work: what you're allowing, what needs administrator approval, and how you stay in control.

The training guide now better explains how What's New works after updates and reminds you it's always available on the Help menu.

The training guide no longer includes an optional clean-up step that many found confusing, making the lesson easier to follow from start to finish.

Updated training backlog tracking to mark the `run-software-update` task as completed (moved from 376 open sessions to the done list). The task covered update procedures, the update badge, and Help > Check for Updates functionality, now fully addressed by the new guide.

The "Update Margin Master to the latest version" task (run-software-update) has been marked as complete in the training backlog, moving from 376 open support sessions to the done list now that the interactive guide is available. This was the most frequently requested training topic across all classified support chats.

The training guide now gives clearer instructions on what to do if an update doesn't complete successfully.

Several existing training guides now cover additional related topics and one correction was made to accurately describe the Rounding Schemes editor layout.

Reorganized the training catalog to include five top-level topics (previously three): Getting Started, Pricing & Analysis, Vendor-Specific, POS Systems, and Database. Added new sections within Pricing & Analysis (Strategies, Troubleshooting) to accommodate the growing guide library. The catalog structure now supports 134 total entries with clear subtopic organization.

The ten new guides directly address the most frequently asked support questions identified from 7,893 chat sessions: reinstalling after a failed update (96 sessions), creating pricing rules (88 sessions), troubleshooting strategy results (84 sessions), investigating count discrepancies (81 sessions), fixing pricing mismatches (55 sessions), setting up Epicor connections (44 sessions), managing SKU exceptions (42 sessions), troubleshooting SKU prices (41 sessions), excluding items from price changes (38 sessions), and configuring zone pricing (31 sessions). This reduces the need for live support on these common workflows.

Training topics are now better organized, with database tasks in their own section and price change day broken into clear steps.

SKU exceptions now have a dedicated training guide explaining that they stay in effect permanently until you remove them—they don't expire on their own.

A new guide explains all four ways to exclude items from price changes, from temporary exclusions in a single rule to permanent protections for specific SKUs.

Improved existing lessons with better coverage mapping and fixed several documentation errors about printing, filtering, and menu locations.

The training guide now correctly explains that What's New appears after updates based on your settings, and reminds you it's always available on the Help menu.

The final step of the training now clearly guides you to the next part where you'll send price changes and print tags.

Training topics are now organized into five clear categories including vendor-specific and POS system guides, making it easier to find relevant help for your store's setup.

The guide shows you exactly where to find Check for Updates in the Help menu and what happens when you click it.

Handbook pages now show which in-app guides walk you through each task, making it easier to launch the right narrated walkthrough.

Training guides are now better organized with new sections for database tasks and price change day workflows.

Regenerated audio file for step 6, removed the audio for the deleted step 7, and updated the render.json manifest to reflect the new step structure and voice settings.

Expanded the lesson catalog structure to include a sixth topic category "Support" with initial subtopic "Troubleshooting", housing lesson 6001 (frozen program). Updated lesson catalog tests to reflect 33 total lessons across 6 topics (Getting Started, Pricing & Analysis, Vendor-Specific, POS Systems, Database, Support).

These seven guides cover 11 keys from the support chat backlog (migrate-mm-to-new-pc, backup-database-and-strategy-files, restore-database-from-backup, execute-price-changes, print-price-tags-labels, export-price-changes-to-pos, finalize-price-changes, reset-database-to-fix-data-issues, clear-orphaned-skus-after-import), reducing the open backlog from 186 to 177 items. Every fact in the guides was verified against window titles, menu paths, and current documentation.

Added 49 narrated audio files (.mp3) and rendering manifests for the seven new lessons, using the en-US-AvaMultilingualNeural voice for consistent narration across all training steps.

Rendered 69 MP3 narration clips for the new lessons using en-US-AvaMultilingualNeural voice, with hash-based render manifests to track text changes. Re-rendered 3 existing clips where narration text was updated (rounding-schemes-4, sku-price-tools-3, when-an-update-fails-4).

Rendered 72 new narration audio clips using Azure text-to-speech (en-US-AvaMultilingualNeural voice) for the 11 new lessons. All render hashes tracked in .render.json files for reproducibility. Training tests updated (33/33 passing) to include new lesson in catalog validation.

Added 10 new interactive lessons covering frequently-requested support topics: managing and moving strategies (#2011, #2014), building rounding schemes from scratch (#2013), using custom groups (#2012), handling strategies after updates (#2015), reconnecting feeds on new computers (#1015), changing database server connections (#5002), fresh store setup roadmap (#1016), frozen program troubleshooting (#6001), Epicor store exclusion (#4002), and Ace Hardware data updates (#3003). Each lesson includes multi-step audio narration, on-screen UI targeting, and auto-advance for guided workflows.

The guided tutorial for executing pricing strategies now has one fewer step, making it quicker to complete while still covering all essential tasks.

Added "Support" as a sixth topic category in the training catalog alongside Getting Started, Pricing & Analysis, Vendor-Specific, POS Systems, and Database, providing better organization for troubleshooting and maintenance lessons.

Updated 8 documentation pages to reference relevant training lessons, including auto-updates, cloud vendor sync, database setup, installation, POS connections, store manager, custom groups, pricing strategies, rounding schemes, and strategy backup/restore. Each page now points users to the specific lesson number they can launch from the Help menu.

Extended lesson metadata to cover 20+ additional support chat tasks including strategy troubleshooting, connection issues, server moves, fresh installations, frozen programs, store exclusions, antivirus conflicts, and more. Lessons now explicitly track which support scenarios they address.

Re-recorded step 6 audio to remove references to the cleanup operations and now directs users to click Finish to proceed to sending changes and printing tags. Removed step 7 audio file entirely.

Generated and embedded MP3 audio files (80+ audio segments) for all new lessons using Azure text-to-speech (en-US-AvaMultilingualNeural voice), providing consistent narration across the expanded training library.

When you edit a rounding scheme and save it, those changes now appear immediately if you reopen the editor. Previously, you would see the old values until you closed and restarted Margin Master, even though your changes were actually saved.

The rounding scheme dropdown in the future price panel now always shows up-to-date scheme settings after you make changes.

Rounding schemes with data corruption are now automatically repaired when Margin Master starts up, ensuring consistent pricing calculations.

Improved the duplicate detection logic that runs after regenerating rounding schemes to distinguish between duplicates caused by the generator (now impossible) versus duplicates from multiple scheme header rows sharing the same name. The system now logs detailed diagnostics showing the number of duplicate groups, header rows, and generated levels, then automatically cleans up any duplicates found, using the same cleanup process as when saving schemes.

Certain rounding scheme configurations would previously stop working partway through the price range, leaving higher-priced items unrounded. These schemes now generate complete pricing tables that cover the full product catalog.

If you had a rounding scheme that seemed to stop working above a certain price (leaving prices unrounded), this has been fixed. All prices will now round correctly according to your scheme rules.

Incremented the rounding scheme generation version from 2 to 3, which triggers a one-time regeneration of all rounding schemes on upgrade. This ensures any existing schemes with stalled pricing tables are automatically repaired. All 850 user schemes tested regenerate identically (byte-for-byte) except for previously stalled tables, which now complete correctly.

Added 150+ new test cases covering all known triggers for the generator stall bug, including right-side rounding fallbacks below the maximum point, rollback rules without supporting right-side rounding, rollbacks landing inside range overrides, and property-based testing with 500 random rule combinations. These tests ensure the generator never creates backwards-stepping bands and always reaches the upper price limit.

Added 150+ lines of test coverage including specific reproduction cases for each stall trigger pattern, a seeded property test that generates 500 random rounding configurations, and validation helpers that detect stalled walks and verify band integrity. The property test reproduced the issue 192 times out of 4,000 random schemes on the old engine; all now pass on the fixed engine.

Incremented the rounding scheme generation version to force regeneration of all existing schemes on upgrade, ensuring any schemes affected by the stall bug are automatically rebuilt with the fix applied.

The lesson library is now organized by category making it easier to browse and find relevant training for your needs.

The lesson browser now organizes lessons by topic and subtopic, making it easier to find lessons on a specific subject. Topics you don't have access to won't appear in your catalog.

You can now browse all available lessons in a tree organized by topic and series, click any lesson to see what it covers and where you left off, then press Start when ready.

Browse lessons in a new library view with a tree on the left and full details on the right, including all steps and where you left off. Search for lessons by name, click one to read about it, then press Start when ready.

When browsing training content, you'll now see items marked as either lessons or guides. Lessons show you around without changing anything; guides walk you through real tasks step-by-step.

Lessons teach concepts by showing you around the screen. Guides walk you through real tasks like creating a database or importing data – you do each step yourself, and the guide waits for you to complete it before moving on.

Click the new training button to access guided lessons and step-by-step guides that teach you how to use Margin Master. Lessons explain features with narration and spotlights, while guides walk you through real tasks like setting up a new database or importing your sales data.

Internal development tool only—not visible to customers.

Related lessons can now be linked together in multi-part series that automatically guide you from one part to the next.

Some lessons are now organized into multi-part series that you can navigate through step-by-step, with automatic skip over any parts you don't have access to.

During lessons, the training card becomes a small speech bubble that automatically moves to point at each step's target, staying out of your way while guiding you through the task.

During a lesson, the window becomes a speech bubble that sits next to whatever you need to click, with an arrow pointing at it. It follows each step automatically, or you can drag it aside if it's in your way.

Use the new "Creating a new database" guide to set up a fresh database for your store step-by-step, with voice narration explaining each choice.

The new "Main window overview" training series walks you through every part of the main screen, from menus to buttons to the pricing grid, explaining what each area does and how to use it.

A new six-part lesson series explains every part of the main screen: menus, selection boxes, buttons, the grid, the summary and the pricing panel.

You can now use Training / Guide Mode to walk through creating a brand new database for your store. The guide highlights each field and button as you fill out the form.

New step-by-step guides walk you through creating a database for your store and loading your point-of-sale data, so you can get started with Margin Master quickly and confidently.

The training bubble now stays out of the way of menus and dialogs, making it easier to follow along with each step.

Lesson numbers have been reorganized so the number itself indicates what topic it covers (1000s = Getting Started, 2000s = Pricing & Analysis, etc.).

Lesson numbers now indicate their topic area—for example, lessons starting with 2xxx are about pricing and analysis, while 1xxx covers getting started.

The training card now opens in the centre of your screen and stays visible even if you unplug a monitor, and it remembers where you last put it.

You can keep the lesson library open while a lesson plays using the narration bar at the bottom, or switch to the speech bubble by clicking "Back to lesson" in the header.

You can now keep the lesson library open while a lesson plays—controls at the bottom let you step through the lesson while seeing the full lesson list.

The training bubble now automatically moves out of the way of menus and windows, so you can always see what you're clicking.

New training guides now walk you step-by-step through setting up a fresh database and importing your store's sales data.

On smaller screens, the lesson list temporarily hides itself when a dialog opens, then reappears when you close the dialog.

On smaller screens, the training card automatically moves aside when a dialog opens so you can see both, then returns when you close the dialog.

Lessons now show icons indicating whether you've started them, finished them, or are currently playing them, and you can see at a glance how many lessons in each topic you've completed.

Training bubbles now stay out of your way when you switch to another program, and during guided walkthroughs you can click the actual buttons and menus being explained.

Lesson series now always start from the beginning, making it easier to review any part.

When working through a multi-part lesson series, you'll see which part you're on and can easily jump to the previous or next part using the new buttons.

The intro lesson now explains how to use the lesson library and speech bubble instead of the old training interface.

Each lesson and guide now starts from the beginning every time, making it easy to refresh your knowledge whenever needed.

Training bubbles now step aside politely when you switch to another program, then come back when you return to Margin Master.

The first-time training introduction now shows you how to move the lesson window and find lessons in the new browser layout.

The training window remembers whether you had the lesson list open or closed and reopens that way next time.

The introductory "Training Mode" lesson now explains the new library and speech-bubble interface.

The lesson list now stays open next to the lesson player so you can see what other lessons are available while learning. Click "Lessons ▸" in the header to show or hide the list.

The lesson list now appears beside the lesson card instead of in a separate window, so you can browse other lessons while one is playing.

The toolbar button for Pricing Equation Analysis has been removed to simplify the interface. If you need this feature, it's still available in the Strategy menu.

Drag the training window to any spot on your screen — it will reappear there the next time you open lessons, even after restarting the application.

Lessons are now organized by topic with your progress shown on each one, and multi-part lessons have a "Start Series" button that takes you through them in order.

The training window now fits completely on laptop screens — you'll always see every button and control without needing to resize your application.

The lesson catalog now supports additional metadata fields including topic, subtopic, order (for sorting within topics), summary (one-sentence description), series information (series ID, part number, series title), and maintains the existing audience filtering. Catalog entries are sorted by order, then number, then series part within each topic section.

The library mode defaults to 820×560 (up from 700×420) to accommodate the tree and description panes. The callout mode uses a fixed 400×300 size. Both modes remember their last user-dragged position separately and clamp to the monitor's work area on startup, ensuring the window remains accessible on smaller screens like laptops.

The Training Mode feature has been renamed to "Training / Guide Mode" to better reflect that it includes both lessons and hands-on guides.

Look for "Training / Guide Mode" in the Help menu and the "Lessons & Guides" button in the title bar when training mode is on.

Multi-part lessons now show which part you're on and have Previous and Continue buttons to move through the series.

The "Lessons" button in the header now switches between the full library and the compact speech bubble while a lesson plays.

Lessons now start by telling you exactly what they cover, and the welcome tour only plays once a day.

The first-time training tour now shows you how to move the card and find lessons by topic.

Tree rows now show chevrons (▸/▾) for expandable groups, and state glyphs for lessons: empty circle for not started, half-filled circle (◐) in accent color for in-progress, checkmark (✓) in green for completed, and filled circle (●) in accent color for currently playing. The selected lesson is highlighted with a semi-transparent accent background. Part numbers (e.g., "1.") appear before lesson titles in multi-part series.

Adds named targeting for button bar items, data flyouts, toolbar containers, and menu items, allowing lessons to accurately spotlight specific UI elements. Resolves visual tree containers to find actual spotlight targets, improving the precision of visual guidance during training.

The bubble's tail is a WPF `Path` element positioned outside the 14px margin grid to avoid WPF's layout clipping, and dynamically placed on the right, left, bottom, or top edge depending on which side of the target fits best within the monitor's work area. The tail points directly at the center of the spotlighted control.

Training lessons and audio are stored as embedded resources with a content mirror system that downloads JSON and MP3 files to a local cache folder. The render sidecar tracks SHA256 hashes of narration text to detect which audio files need re-rendering when wording changes. Content is served from the `marginmasterdownloads/training` blob container.

Replaced `LessonBrowserViewModel` (172 lines) with `LessonLibraryViewModel` (291 lines), which maintains a flattened tree of `LibraryNode` and `LibraryRow` objects for efficient rendering without a WPF TreeView control. The view model now loads lesson content on demand to populate the description pane, tracks expansion state for topics and series, supports filtering, and handles selection separately from playback state.

Replaced LessonBrowserViewModel (172 lines, flat topic/series/lesson lists with expand/collapse) with LessonLibraryViewModel (291 lines, tree-based with LibraryNode/LibraryRow hierarchy, selection state, search filtering, and LessonDetail for the description panel). The new architecture flattens the expanded tree into rows for rendering without a TreeView control, enabling custom styling and single-click selection with double-click activation.

The button row documentation has been updated to reflect the removal of the Pricing Equation Analysis button from the toolbar's technical reference.

All new catalog fields (topic, subtopic, order, summary, series, part, seriesTitle) are optional, ensuring existing lesson catalogs and the content sync system continue working without modification. The flat lesson list remains functional, and the LessonCatalog.Topics() method derives the browsable tree from the new fields when present. Cloud catalog will need to be re-uploaded after deployment to take advantage of the new organization features.

Added MM_TRAINING_LESSON environment variable for developers to start a specific lesson at launch, bypassing the intro. Named UI elements in the Create New Database dialog (cboPrimaryVendor, txtStoreNumber, cboPosSystem, txtDatabaseName, btnValidateLicense, btnCreateDatabase) so they can be targeted by training steps.

Added test-enforced authoring rules: guides cannot use command targets (they never perform steps for the user), must include a summary explaining what they do, and if they change data must mention "End" in the narration. Lessons (tours) cannot use waitFor signals since they advance on Next only. Added x:Name attributes to Create New Database window controls (cboPrimaryVendor, txtStoreNumber, cboPosSystem, txtDatabaseName, btnValidateLicense, btnCreateDatabase) to support guide targeting.

On development machines where the lesson source folder is detected, adds an in-app editor (✎ button on the bubble) for changing step titles and narration. The workflow is: edit text → Read it back (renders with Azure text-to-speech en-US-AvaMultilingualNeural voice and plays preview) → Approve and publish (updates source JSON, saves MP3, updates render sidecar, mirrors to content folder, and uploads to Azure blob storage via `az` CLI). The media player is released before file replacement to avoid locks. Uses AZURE_SPEECH_KEY or falls back to Azure CLI authentication.

Added targetable elements for spotlight highlighting within the training window itself: TrainingWindowHeader (drag handle), btnBrowseLessons (toggle button), LessonBrowser (scrolling list), AllLessonsHeading, and LessonIdBox. The overlay sits under the card so spotlights on the card itself are narration-only without visual highlighting.

Added TrainingWindowMoved signal raised when the user drags the training card to a new position, enabling lessons to wait for and teach window repositioning as an interactive step (used in the revised training-mode introduction lesson).

Export error messages now explain why the operation failed (for example, "access denied" or "file is locked"), not just which file was affected.

The automatic backup folder (used for database and strategy backups) is now recalculated each time from the current import path setting rather than cached at startup, ensuring Options changes take effect immediately. Falls back to ProgramData when the derived path cannot be created.

When no custom export or import folder is configured, Margin Master now consistently uses C:\MarginMaster for all operations instead of sometimes trying to write to the C:\ drive root (which Windows blocks for standard users).

If Margin Master can't save settings because of Windows permissions, you'll now see an error message at startup that lists exactly what's wrong and tells you to ask your administrator to grant Modify access to the settings folder.

The error message shows exactly which files can't be written and tells you who to contact to fix the permissions.

The new ProgramDataAccessCheck helper performs two validation steps: creates a test file to verify the directory is writable, then attempts to open every existing *.json file in the folder root for write access. This two-tier approach catches the specific scenario where folder ACLs allow new file creation but existing files have restrictive permissions from being created under a different user account. File locking by other processes is explicitly treated as non-fatal (contention is not a permissions problem).

Replaced the IGlobalFileConfigService.DefaultExportPath / DefaultImportPath properties and their internal GetValidPath / TryCreateDirectory helpers with new extension methods on IApplicationSettingsService (ApplicationSettingsPathExtensions) and IImportSettingsProvider (ImportSettingsProviderPathExtensions). Added MarginMasterPaths.ResolveImportExportFolder and NormalizeImportExportFolder as the single pure resolver all 67 call sites now share, with 16 test cases pinning normalization, fallback, and creation behavior.

Stores with their own IT departments can now share official setup instructions for configuring SQL Server when running Margin Master on multiple computers.

Export failures now surface the operating system's error message (access denied, file in use, path not found) alongside the full file path, making it easier to diagnose export problems without guessing which folder was attempted.

Modified the firewall and network requirements guide to link to the new customer-facing SQL Server setup guide instead of the support-only script documentation. The script reference has been moved to a support-only section so it remains available to internal staff but doesn't create broken links for customers.

The path normalizer now treats a bare drive letter (C:\ or C:) the same as a blank setting and substitutes the default folder. This prevents the original MM-1446 condition where a malformed or incomplete setting resulted in write attempts to the drive root.

Added a related link from the internal support script documentation to the new customer-facing guide, making it easy for support staff to direct customers to the appropriate resource.

Exports that previously failed with "Access denied" will now succeed. The export path shown in Options will match the path actually used by all export operations.

Created MarginMasterPaths.ResolveImportExportFolder() and extension methods on IApplicationSettingsService (GetDefaultImportPath/GetDefaultExportPath/SetDefaultImportPath/SetDefaultExportPath) so all 34 readers of these settings see the same normalized value. Removed duplicate path-resolution code from GlobalFileConfigService and individual ViewModels.

When you start a training lesson, a small window appears with spoken instructions. The screen dims except for the button or menu you need to click, which pulses with a highlight. After you complete each step, the lesson moves forward automatically or when you click Next.

Training lessons now play with a professional voice instead of robotic text-to-speech, making them easier to follow.

Turn on Training Mode from the Help menu to see lessons. The window gets a glowing blue border and the title bar shows a "Show Lessons" button.

When working with support, you can now use lesson numbers like "1001" to quickly start the right training.

When you first turn on Training Mode, a welcome lesson plays automatically to walk you through how to find lessons, understand lesson numbers, and navigate the training system.

Click the blue "?" button on any screen to choose between reading the help page or launching an interactive training lesson that walks you through the task.

When you click "Show Lessons," you'll see lessons for the screen you're on first, then all other available lessons.

The sample training lesson walks you through opening the Tools menu, clicking Options, and finding the Miscellaneous settings page.

The training system now automatically detects when new dialogs open by monitoring the application's window collection and raising "Dialog:{title}" signals. This allows lessons to wait for specific windows to appear before advancing, enabling multi-step workflows that cross dialog boundaries.

Lesson steps can now target any named element in the application, including those inside UserControls, by walking the WPF visual tree. Previously only elements directly accessible through Window.FindName were reachable.

A new lesson shows how to open the Rounding Schemes editor where you set price endings like 99 cents.

The training assistant now stays interactive when guiding you through screens like Options, so you can continue following instructions without the tutorial freezing.

Training lessons now advance automatically after certain actions, making tutorials flow more smoothly without extra clicks.

Added ToLocal method that properly converts spotlight target rectangles from the main window's DPI context into the overlay's local coordinate system, accounting for different DPI scaling on each display. This ensures the dimmed areas and highlight outlines draw precisely around the intended UI elements.

Click any help button (?) and select "Lessons..." to see all available training, even if there's no specific lesson for the current screen.

The welcome lesson waits to make sure all content is loaded before starting, so it won't fail if you enable Training Mode right after opening the app.

When you open a dialog during training, the player automatically moves aside so both windows stay visible, then returns to its original spot when you close the dialog.

The welcome lesson only plays the first time you turn on Training Mode each day—toggling it off and on again won't replay the introduction.

The training player now reliably stays on top and clickable even when other windows are open, so you can follow along with lessons without interruption.

The spotlight overlay (which dims the screen and highlights the target) is now shared between Training Mode's glowing frame and active lesson steps, rather than creating a new overlay for each lesson. This prevents visual conflicts and ensures smooth transitions.

Applied ModalSurvivor to the lesson list window so it remains usable when other dialogs are open, consistent with the training player window behavior.

When using interactive training while Margin Master is maximized, the spotlight overlay now properly fits the window without extending past the screen edges.

When using multiple monitors with different display scaling settings, training spotlights previously appeared offset from the highlighted area. This is now fixed and spotlights align correctly.

The blue glow that appeared around the window edges during training lessons has been removed because it was spilling onto other monitors in multi-screen setups.

When using training mode with Margin Master maximized, the spotlight overlay now appears in the correct position on your screen.

The interactive training for rounding schemes now correctly waits for the Edit Rounding Scheme dialog to appear before continuing.

Training lessons now work properly when walking you through dialog windows—the training instructions stay visible and usable.

The training spotlight effect now stays properly positioned when you move Margin Master between monitors with different scaling settings.

The training player now looks more modern with a sleek, rounded design and shows your progress through each lesson with a visual progress bar at the bottom.

When following a training lesson, you'll now see "Step 3 of 7" (for example) displayed next to the progress bar, making it easy to know exactly where you are in the lesson.

You can now drag the training player to any position on screen by clicking and dragging the top bar, and it will stay where you put it.

You can now resize the training window by dragging the corner to make it larger or smaller.

In preview builds, you'll see a "Training (preview)" option in the Help menu that starts the sample lesson.

Updated the sample Options lesson with clearer wording, instructing users they can close the Options window at their convenience rather than requiring it before clicking Finish.

Added x:Name identifiers to lesson list UI elements (AllLessonsHeading, LessonIdBox) and the main window's "Show Lessons" button (btnShowLessonsPill), allowing the introductory lesson to highlight and reference these interface elements directly as part of its interactive tutorial.

Reorganized button layout with new pill-style buttons, moved the Exit button to the header for quicker access, added a resize grip in the bottom-right corner, and implemented a StepDots visual progress indicator that shows completed steps in accent color, the current step wider and white, and upcoming steps dimmed.

When training mode is active, the main window shows a subtle cyan glow around its border.

Enhanced Lesson.LoadEmbedded method to extract embedded audio files (MP3) to the local file system on first use, with file existence and size validation to avoid re-extraction. Audio paths in lesson steps are resolved to absolute local paths when an asset folder is provided, enabling the narrator to play pre-rendered audio instead of synthesizing speech at runtime.

MarginMaster.Training is a standalone library with no dependencies on DevExpress or MarginMaster.UI.WPF. The host application implements ITrainingHost (perform actions, locate UI elements) and ITrainingLauncher (start lessons), while the library handles lesson playback, narration, spotlight overlay, and progress tracking. WpfTrainingHost reuses ScreenshotRunner's menu/reflection helpers to drive the UI consistently.

LessonCatalog.FindById() now accepts both slug-style IDs ("rounding-schemes") and short numeric references ("1002" or "#1001"), improving flexibility for support scenarios and documentation references.

Added Render-LessonAudio.ps1 PowerShell script for authoring-time rendering of lesson narration. The script reads a lesson.json file, sends each step's text to Azure Speech REST endpoint, and writes MP3 files to the lesson's audio folder. Supports configurable voice selection (default: en-US-AvaMultilingualNeural), region, and speaking style.

Added diagnostic trace logging to the spotlight overlay to track when the frame is shown or hidden, when the overlay window appears, and when fallback positioning logic is used. This will help diagnose any future issues with the training overlay not appearing correctly or following the main window properly.

Added a debug-only environment variable (MM_TRAINING_MODE=1) that automatically enables training mode at startup, making it easier for developers to test overlay behavior without manual interaction.

Added trace logging throughout the training system that reports step transitions, signal satisfaction, and lesson progress to the application log. This helps diagnose lesson authoring issues and player behavior during development and support scenarios.

Implements LessonProgressStore that saves lesson progress (current step index, completion status) to a JSON file in CommonApplicationData. Lessons automatically resume where the user left off, and completed lessons are marked as done.

Defines a lesson format supporting step narration (text-to-speech or pre-recorded audio), targets (menu items, commands, Options tabs, named elements), wait conditions, and auto-advance. Lessons are cataloged by documentation slug so help buttons can find the matching lesson. The sample catalog and lesson are embedded as resources.

Implements SpotlightOverlay as a transparent, topmost, click-through window that dims the entire screen except for the target rectangle, which pulses with an animated outline. Uses Win32 extended window styles (WS_EX_TRANSPARENT, WS_EX_LAYERED) to allow interaction with the main window while the overlay is visible.

Adds System.Speech package reference (10.0.11) and implements WindowsNarrator using SpeechSynthesizer for text-to-speech and MediaPlayer for optional pre-recorded audio files. Prefers natural-sounding English voices when available, supports cancellation, and runs on the UI thread as required by MediaPlayer.

Training lessons automatically update from the cloud when you turn on training mode, so you'll always have the latest content without needing to update the application. If you're offline, the app uses built-in lessons so training always works.

Training lessons may now be customized for your specific vendor, POS system, or even your individual store.

You can now type a lesson ID from the documentation into the lesson list and click Start to jump straight to that lesson.

When you open Margin Master, it now quietly downloads the newest training lessons in the background so they're ready whenever you need them, even if you go offline later.

Training Mode menu visibility changed from a debug-only compile-time flag to runtime check based on IsSupportMachine property. The menu item now appears only on machines registered in RS_Data.SupportMachines and verified via the /api/support/machines/check endpoint, ensuring training features are restricted to authorized support personnel.

The background refresh task logs any failures but allows the application to continue using cached or embedded lessons without interruption. Screenshot mode automatically skips the refresh to avoid external network calls during automated testing.

When training mode is activated, the app syncs content from the cloud and then reloads the lesson catalog, ensuring newly published lessons appear immediately. The TrainingLauncher now exposes a ReloadCatalog method to refresh the catalog from the updated content folder without restarting the application.

The cloud sync process now downloads the lesson catalog first, filters it by the current store's context (vendor, POS system, store number, and organization), then downloads only the applicable lesson files and their audio narration. This reduces bandwidth usage and local storage while enabling vendor-specific or store-specific training content.

Removed IsTrainingPreviewVisible property from MainMMViewModel and simplified XAML binding to directly use IsSupportMachine. This eliminates technical debt from the training mode spike and aligns the feature with the application's existing support machine authorization system.

The blue glow effect around the window in training mode has been removed for a cleaner look.

The training lesson list now shows only lessons relevant to your store's vendor and point of sale system.

The training host now provides the store's configuration context (vendor type, POS system type, store number, and organization ID) to the training launcher. This context is used to filter the lesson catalog when loading from either embedded or cloud-synced content.

A new service pulls training content from Azure blob storage, comparing blob modification times against local files and downloading only what has changed. Files are written to a temporary .download file and moved atomically to prevent corruption. Failures are logged but never disrupt the user experience since embedded content remains available.

Updated the Propello import guide documentation to reflect the new confirmation message wording, ensuring consistency between the application and help documentation.

Failure reasons in the push report now include more detailed validation messages from the Propello library itself, providing better context when items cannot be uploaded during bulk operations or retry attempts.

When a price update fails to push to Propello, the error report now clearly shows which SKU and store were affected instead of running the numbers together.

When you send prices to Propello Price Review and some items are already waiting there, the confirmation message now more clearly explains that sending again is safe: any SKU you're re-sending will have its price updated, but other items already waiting won't be removed.

Before sending prices to Propello, if some items are already waiting, you'll see a clearer explanation that re-sending a SKU replaces its pending price without removing anything else from the queue.

When pricing updates fail to upload to Propello, you'll now see each failed item clearly labeled with "SKU [number] @ store [number]: [reason]" instead of confusing columns that ran together.

New *How Margin Master Thinks* page introduces the three foundational ideas behind the application: vendor pricing as a baseline (not the final answer), hierarchical strategy execution, and rounding as a margin improvement tool. Serves as the handbook's conceptual introduction before installation chapters.

Added *Prerequisites* page covering system requirements, SQL Server versions (2022/2025 supported), network needs, and pre-installation checklist. New *Install or Upgrade SQL Server Express* and *Install or Upgrade SQL Server Management Studio* pages document the SQL Server Tools window's guided installation process, including instance naming (`MARGINMASTER`), backup behavior during upgrades, and reboot handling. The older in-app installer documentation is now support-only.

Expanded "Load Saved Selection" documentation to "Save and Load Saved Selections," now covering the camera button workflow for saving the current selection boxes and Future Price panel settings as a named snapshot, and explaining how saved selections serve as both reusable filters and strategy steps.

Split the main window orientation into focused pages: *The Menus* (every menu item with keyboard shortcuts), *The Button Row* (all 10 toolbar buttons numbered with explanations of vendor SKU vs. non-vendor SKU filtering), *The Main Data Grid* (column meanings, color coding, symbol columns, right-click actions), *The Summary Section* (Displayed/All/None modes, monthly impact columns, export options), and *Banners and Badges* (every title-bar pill and banner with meanings and actions). *Main Window Orientation* is now the chapter's landing page linking to each detailed page.

The Store Manager guide now clearly explains why matching your stores to vendor store numbers is essential for correct pricing, and how to fix stores that show "needs setup" or import zero items.

You can now look up your point-of-sale system in the handbook's POS Systems chapter and find either a complete import guide or a page confirming the system is supported with next steps.

Added documentation explaining how pricing strategies execute top-to-bottom with last-step-wins behavior, using a worked example of a hardware store pricing paint at 42% margin while holding sensitive items to Level 1 price. Emphasizes general-to-specific ordering and how PSRule shows which step finally priced each SKU.

Added first-draft *Printing and Exporting* and *Rebuild Data* pages so new pages' links resolve; these will be expanded in later phases. All pages carry proper frontmatter matching `handbook-map.json` structure (part, chapter, order).

You can now see a complete list of every point-of-sale system Margin Master works with, even if detailed setup instructions are still being written.

Added step-by-step documentation for creating a strategy step from the main window: set selection boxes, configure the Future Price panel action, then press the camera to save the snapshot as the newest step in the active strategy. Explains all "Set Future Price to" options including vendor price levels, target margin, cost breaks, fixed retail, and margin snapshot.

The handbook now explains how to set up Do it Best mailbox connections, test them, and configure Ace Direct SKU handling through the Options window.

Added documentation for managing existing strategy steps in the Strategy Manager, including re-ordering with Up/Down buttons (Ctrl for 5 places, Alt for top/bottom), activating/deactivating steps, renaming, editing conditions and rounding, and the Load workflow for changing a step's core selection or action.

New guide helps you diagnose and fix issues when vendor data sync fails or doesn't update prices as expected.

The handbook now covers how to group stores for shared pricing and how to diagnose why vendor data sync might fail or appear incomplete.

Added documentation covering pre-run strategy review (checking step order, SKU counts, active status), executing with Ctrl+X, interpreting the Strategy Execution Summary (sitting margin, profit impact, "Not priced" warnings), and using "Show Skus NOT included in Strategy" to find items no step priced.

Advanced multi-store users can now learn how to group stores together for unified pricing across locations in the same market.

The Store Manager guide now explains clearly why matching your stores to vendor numbers is required for accurate pricing and how to fix stores that won't import.

Each POS import guide now includes a troubleshooting table showing what to check when imports fail or data doesn't appear.

Every POS import guide now includes a troubleshooting table to help diagnose common issues like "no files found" or imports that complete but don't update the grid.

The database troubleshooting guide now starts with common symptoms like slow refreshes and tells you which tool to run first, making it easier to fix performance problems without needing database expertise.

The vendor sync documentation now clearly shows which vendors are fully supported and which are in development.

The vendor sync guide now mentions True Value members and Emery Jensen stores and explains that your chosen vendor determines which catalog data is synced.

The handbook now includes step-by-step guides for every setting in Tools > Options, making it easier to configure import paths, export formats, vendor connections, and data preferences.

The handbook now explains every setting in Tools > Options, where to find import/export paths, how to test POS connections, and what each vendor-specific option does.

Added complete guide explaining how selection boxes work on the main window, including left-click include vs right-click exclude behavior, Shift-range selection, type-to-scroll navigation, how boxes combine (OR within, AND across), and special comparison boxes for price, cost, margin, quantity, and date fields. Also documents the PSRule box, Store Number display options, and the F12 clear-all shortcut.

You can now read about how Margin Master updates itself and choose the update method that works best for your computer in the new handbook chapter.

User-facing text now says "Margin Master support", "Margin Master cloud" and "Margin Master licensing server" instead of RetailerSoft. RetailerSoft remains where it names the company (installer signature, file paths under %ProgramData%\RetailerSoft). The engineering notes file at the docs root gained internal-only frontmatter so it no longer publishes publicly; the firewall guide is now in the search index.

Clear guidance now available on where to configure your point-of-sale connection based on which system your store uses.

The Excel import feature now has its own detailed guide showing how to map spreadsheet columns to Margin Master fields and save those maps for reuse.

You can now read step-by-step instructions on how to use cost break models in your pricing strategies to apply sliding margins based on item cost ranges.

New handbook pages explain how to look up vendor catalog information for any SKU, view what changed in each version update, and use the help buttons found on most Margin Master windows.

Added numbered `button-row.png` screenshot with 10 labeled buttons; main window screenshots updated with support-only icons redacted from toolbar (Implementation Plan and Pricing Equation Analysis buttons blanked in manifest).

Every doc under docs/marginmaster/ now carries part / chapter / order frontmatter mirroring the new docs/handbook-map.json, which defines Introduction + Parts I–VIII across 21 chapters. HandbookMapTests in MarginMaster.Tests fails the build when a doc is missing from the map, frontmatter disagrees with the map, two docs share an order in a chapter, or a user-only doc is parked in the appendix. Reference material (installation scripts, catalog-file layouts, engineering notes) stays in an Appendix on purpose.

The online help now includes detailed guides on using selection boxes, saving your work with the camera button, and building pricing strategies step-by-step with real examples.

Added HandbookMapTests.cs with four enforcing tests: every doc is placed in a chapter or listed in the appendix on purpose, frontmatter matches the map, orders are unique within each chapter, and user-only docs are not parked in the appendix. Drift between the map and the files now fails the build instead of silently scrambling the handbook's reading order.

New `docs/sync-handbook-map.py` Python script regenerates `handbook-map.json` and `index.json` from document frontmatter, ensuring the table of contents, navigation links, and search index stay in sync with the docs. Handbook now has Introduction (Part 0) plus Parts I–VIII with 21 chapters.

This phase completes the handbook's first full pass with Introduction plus Parts I–VIII, every chapter now populated. Includes 826 lines added across 12 documentation files, updating the handbook map, search index, and changelog. Co-authored with Claude.

Updated handbook-map.json and index.json to organize the new pages into Chapter 13 (Selection Boxes) and Chapter 15 (Building Pricing Strategies) within Part VI (Learning Margin Master), with proper ordering, search keywords, and cross-references.

Updated handbook-map.json with 213 new lines placing all new pages into the correct Parts/Chapters (Part III Initial Configuration gains Chapter 6 Tools > Options with 6 docs, Chapter 7 POS Systems gains 46 docs, Chapter 8 Store Manager gains store-grouping cross-reference; Part VII Advanced Topics gains Chapter 18). Regenerated index.json with 2,254 new lines covering all new pages, updated timestamps, corrected titles, and refreshed body excerpts. All 17 modified POS guides and 8 new/modified Getting Started pages carry last_updated "2026-08-28".

Added options.manifest.json defining screenshot capture specifications for the Options window (window-relative crops at 1600×1000, showing navigation, tabs, and buttons) with shots for overview, Miscellaneous tab, Export Options tab, and Ace Hardware tab.

Updated handbook-map.json with 213 new entries organizing the Options, POS Systems, and Store Manager chapters; regenerated index.json with 2,254 additions reflecting all new pages, updated titles (Store Manager → "Store Manager: The Hub of Data Processing"), reordered items (Supported POS Systems now order 2 in Chapter 7), and search keywords for every new guide.

When setting up cost break pricing levels, typing a target margin percentage like "70" now correctly saves as 70% instead of 7,000%, and the calculated prices will be correct.

If you previously entered a Target Margin like "70" and saw strange negative prices, those cost breaks will now calculate correctly. Any affected cost break strategies will automatically heal when you view them.

Cost breaks that were previously saved with incorrect margin values (showing thousands of percent) will automatically fix themselves and start working correctly.

Changed BuildCostBreakSQL to emit From/To/TargetMargin values using InvariantCulture formatting to prevent localization issues where decimal separators could corrupt the generated SQL on systems with different regional settings.

When editing Target Margin in cost break levels, the cell now guides you to enter values as percentages and prevents incorrect entries.

Added comprehensive unit tests (CostBreakTargetMarginTests) to verify that whole-percent values (1 or greater) are correctly converted to fractions, while existing fractional values and edge cases remain unchanged.

Added comprehensive unit tests (CostBreakTargetMarginTests) to verify that whole percent values (70, 42.5, 100) are converted to fractions (0.70, 0.425, 1.00) while existing fractional values remain unchanged, preventing regression of this critical pricing bug.

Go to Tools > Options > Propello, enter your Propello URL (for example "anchorace" or "https://anchorace.epicorretailcloud.com/"), username and password, then click Save & Test. Margin Master will verify the connection and save it. If the test reports a permissions problem, ask your Propello administrator to grant the listed rights to the user, then test again.

Set up the connection once in Tools > Options > Propello with your store's Propello web address and login. After that, Get POS Data downloads your inventory automatically.

After connecting Propello in Tools > Options, click Data > Get POS Data. Margin Master will download the product export from Propello and show how much time is left. If it fails, you can still import an Excel file you exported from Propello yourself.

Use Print/Export and choose "Propello Price Review" to send your price changes straight into Propello — they land in Price Review for you to approve in the portal.

Select the rows you want to change in Propello, click Print/Export, choose "Propello Price Review" and enter the date you want the new prices to take effect. Margin Master will send the changes to Propello Price Review (they will not be finalized automatically) and show you what was uploaded.

If you haven't set up Propello yet, clicking "Get POS Data" will now show a helpful message asking if you want to set up the connection now, making first-time setup easier.

When you open Propello settings, Margin Master now checks what connections are saved in the cloud and updates the Restore from Cloud button accordingly.

A new centralized RscGate decision point now applies the same RSC validation rule at every Do it Best per-store build site: the drain rebuild, BisTrack Direct SQL and CSV imports, legacy BCP ingest, Propello, and Compass catalog merges. This ensures no import path can bypass the RSC requirement or accidentally build against the wrong catalog.

The GetSpecificRSCResponse model now includes IsResolved and RequiresRsc properties that clearly indicate whether a store can be built. The fallback ladder (ResolveEffectiveRsc) that borrowed RSCs from other sources has been removed. A new RscGate service provides a single, testable decision point used by all import paths (drain, BisTrack preload, legacy BCP ingest, Propello/Compass merges) to enforce the "no RSC means not built" rule consistently.

The Restore from Cloud button is now disabled until you've successfully saved at least one Propello connection, with a clear explanation of why it's unavailable.

Progress messages during Propello imports now display time information more cleanly without duplication.

Propello's Inventory Viewer export (requested through the API with the "Margin Master (Auto)" saved view) uses different column headers than the hand-exported Products grid ("Store Number" vs "Store #", "curr_month_less_0_sales_units" vs "Feb-26"). Import column definitions now recognize both spellings through aliases, so cloud downloads and manual exports import through the same code path without requiring schema changes.

The new Propello tab in Options includes a "Save & Test" button that validates credentials by logging in and creating/repairing the saved view Margin Master needs. Propello connections are backed up to the RetailerSoft cloud after a successful test and can be restored from the cloud if the local settings are lost, matching the workflow for other POS connections.

RemoveDuplicatesFromMainTable now runs after every per-store build (previously skipped by some import paths), is guarded to safely handle missing tables, and orders by [ID] to keep the first-inserted row rather than picking arbitrarily. This ensures exactly one row per (StoreNumber, SKU) in every main table.

When a Propello operation fails, Margin Master explains the problem in store-owner terms: "bad credentials" if the username/password is wrong, "permissions issue" if the Propello user lacks required rights (with a list of the rights needed), and "portal or network" for timeouts or connectivity problems. A manual fallback lets stores import a hand-exported file if the cloud download fails.

If you use BisTrack CSV imports and noticed the same item appearing multiple times in your pricing grid after import, this fix ensures each SKU loads only once. Verified with a 22-store customer file: 23,712 SKUs now correctly produce 23,702 distinct entries instead of 93,459 duplicated rows.

Previously, after importing BisTrack CSV files, you would see the same SKU repeated multiple times in the pricing grid. This has been fixed—each SKU now appears only once after import.

Do it Best stores must now have their own RSC assigned in Store Manager to import correctly. If a store is missing its RSC, it will appear in the "NOT IMPORTED" list at the end of the import with instructions to set the RSC and re-import.

If your Do it Best store doesn't import, check the import results screen for "no RSC set in Store Manager" — open Store Manager, set the correct RSC for that store, and re-import.

When importing Propello API exports, all 240 columns of data are now successfully imported. Previously, the last five columns were silently lost.

BisTrack Direct SQL stores were previously exempt from RSC filtering (skipRscFilter flag), which caused every SKU to appear multiple times when multiple RSCs existed in the catalog. This exemption is removed—all Do it Best stores now filter by their assigned RSC.

The RemoveDuplicatesFromMainTable SQL query now keeps the first-inserted row (lowest ID) when deduplicating on StoreNumber and SKU, rather than letting SQL Server pick arbitrarily. The query is now guarded to safely run on tables that may not exist. All Do it Best import paths (BisTrack 1040, BisTrack 6828, legacy BCP, drain refresh) now run this deduplication step.

The legacy BCP ingest's RSC filter targeted outdated SQL syntax that the query builder no longer emitted, causing the filter to silently fail. The replace logic now targets the correct JOIN syntax and validates that it matches what the builder actually generates.

The RSC filter for BisTrack Direct SQL stores was silently failing because the string replacement targeted outdated SQL syntax that the query builder no longer emits. The replacement now targets the current "LEFT JOIN [MMVendorData] ON [MMVendorData].[SKU] = " syntax and includes validation to detect future mismatches. BisTrack Direct SQL is no longer exempt from RSC filtering — stores at multi-RSC organizations now receive correct, filtered pricing.

Changed the cloud backup during Save & Test from fire-and-forget to awaited, ensuring that CloudConnectionCount is immediately updated to reflect the newly saved connection. This guarantees the Restore button becomes enabled right after a successful save operation.

When importing Propello files, the system now automatically recognizes different header names from API downloads and manual exports, so you no longer need to worry about which export method was used.

All Propello column variations for Ace Hardware and Do-It-Best imports are now recognized automatically.

Both the general Excel file reader and the Propello-specific import service have been updated to handle wider spreadsheets, ensuring compatibility with current and future Propello API export formats.

New users will see a clear explanation of how to connect to Propello, with the option to go directly to the settings screen.

Hovering over the Restore from Cloud button now shows helpful information about whether saved connections are available and how many exist for your store.

Stores that cannot be built due to missing or invalid RSC mappings are logged at Warning level and added to the store configuration issue collector with severity "NotImported". The import results screen displays these stores in a "NOT IMPORTED" section with actionable messages like "no RSC set in Store Manager — set it and re-import" or "RSC '04' is set but the synced vendor data has no rows for it — sync vendor data for RSC 04 and re-import".

After importing, any Do it Best stores missing an RSC will be listed in the "NOT IMPORTED" section with instructions on how to fix the issue in Store Manager.

Three new application settings store the Propello connection: PropelloUrl (normalized https tenant URL), PropelloUsername, and PropelloPassword (DPAPI-encrypted per machine). The password is excluded from the settings-transfer delete-on-default list so it always persists, and all three are backed up to the cloud after a successful test.

Introduced a new property on the POS import handler interface that allows handlers to signal whether they built the per-store main tables during the ingest phase. This flag is now passed from the handler through the Import Manager to the main import process, ensuring the rebuild step has accurate information about what work has already been completed. Added comprehensive unit tests to prevent future regressions by ensuring this flag travels the correct path through the application.

GetSpecificRSCResponse now carries RequiresRsc, MappedRsc, and IsResolved properties instead of fallback tracking (UsedFallback, FallbackSource). The ResolveEffectiveRsc ladder method and its tests are deleted—there is no longer any RSC borrowing logic.

Introduced comprehensive unit tests (PosIngestBuiltMainTablesFlagTests) that enforce the correct path for the "main tables built during import" flag. These tests verify that MainMMViewModel never reads the flag from its own service instance, that ImportFilesViewModel correctly retrieves it from the handler, and that all BisTrack handlers properly report whether they built the tables. This prevents future regressions of the quadruplication bug.

The MarginMaster.Propello library (sibling repo, cloned by publish.yml next to FileHelpers.Core) is referenced as a ProjectReference and wrapped behind one interface (Services/Propello/IPropelloConnectionService implemented by PropelloConnectionService). No other Margin Master file sees the library namespace — all consumers (ViewModels, tests) talk in library-free DTOs (PropelloConnectionSettings, PropelloProgressInfo, PropelloTestResult, PropelloDownloadResult, PropelloPushOutcome, PropelloUserError). The pure helpers (PropelloUrlNormalizer, PropelloUserMessages, PropelloSplashProgress, PropelloPriceChangeBuilder) are unit-tested in MarginMaster.Tests/Propello/PropelloIntegrationTests.cs (34 tests) without needing a live Propello tenant. Credentials are backed up to api/pos/credentials (new PosCredentialDescriptor.ForPropello, AuthMode=Web) and reported after each import like the other POS types. Documentation added: propello.md, import-propello.md, index.json, version-map.json, CLAUDE.md updates.

Added PropelloHeaderAliasTests validating that the 240-column API export header row resolves correctly, that hand-exported headers remain unchanged, and that alias matching is case-insensitive. Added integration test ensuring the progress message formatting handles library-appended elapsed time correctly.

A new sibling library (MarginMaster.Propello) handles all direct interaction with the Epicor Retail Cloud portal: login, saved-view creation, report export download, Price Review status checks, and price-change upload. The library is referenced only by PropelloConnectionService; the rest of the application (ViewModels, tests) works with library-free DTOs, keeping the portal-specific logic isolated and unit-testable.

If you install Margin Master on a new computer, your Propello connection settings will be automatically filled in from your cloud-saved configuration. You'll see a message showing when the connection was last validated, and you just need to click "Save & Test" to confirm it still works.

When setting up Propello for the first time, clicking "Yes" on the connection prompt will now take you directly to the Propello settings tab instead of making you find it yourself.

The Propello URL field now shows a clearer example of what to type.

The message about contacting your Propello administrator for permissions issues was moved from the static help text to an italicized note at the bottom of the contextual help panel, making it visible regardless of which field is focused.

When setting up your Propello connection, click into any field to see specific instructions about what to enter there. The help panel on the right updates automatically to guide you through each step.

Click Help > Legal to open any of the three legal documents in your web browser.

The Help menu now includes a Legal submenu where you can view the End User License Agreement, Privacy Policy, and Terms of Use by clicking on any of these options.

Replaced the placeholder MIT license template in LICENSE.txt with the actual proprietary licensing terms. The file now clearly states that Margin Master is licensed software (not sold), references the online EULA, and notes that vendor data is confidential proprietary information that may not be disclosed or duplicated except as permitted by the EULA.

The LICENSE.txt file has been replaced with a proprietary license notice indicating that Margin Master is licensed software owned by RetailerSoft, Inc. The file now references the EULA and related policies available at marginmaster.com, establishing the website as the authoritative source for license terms.

When you open Margin Master, if Windows runtime files are missing (often due to antivirus quarantine or a failed Windows update), you'll see a dialog listing exactly what's missing with a button to repair it automatically.

On launch, Margin Master now checks that all the Windows system files it needs are intact. If something is missing, you'll see a clear message explaining what's wrong instead of cryptic errors later.

A red warning badge stays in the title bar until the runtime is actually fixed — you can't accidentally dismiss it and forget about it.

When Margin Master finds a problem with the Windows runtime, a red warning appears in the title bar. Click it to run an automatic repair — Windows will ask for permission, then the script downloads and fixes the issue. The warning disappears once the repair finishes.

Improved the version gate logic to treat declining as an expected, safe user choice rather than an error condition. The application now properly cleans up and hides the loading splash screen when users choose not to proceed with opening a newer database.

If cloud sync keeps failing with every table erroring out, Margin Master now checks whether a Windows runtime file is missing and walks you through the repair instead of just saying "check the log."

The "Install .NET Runtime" support script is now smarter — it checks what files are missing, repairs the existing installation if it's up-to-date, or installs a newer version if available, then verifies the fix worked.

If Margin Master crashes with a missing-file error while you're working, it now recognizes when the problem is a damaged Windows runtime and offers the repair tool rather than a cryptic error message.

The repair script now checks your installed runtime first and tells you exactly which files are missing, then either installs a newer version or repairs the current one, and re-checks afterward to confirm the fix worked.

If you see a warning that a database was created by a newer version of Margin Master and click "No," the app will now stay open normally instead of crashing.

If you're asked whether to open a database file from a newer version of Margin Master and click "No," the app will now continue running normally instead of crashing.

If a cloud sync fails because Windows system files are missing, Margin Master now tells you exactly that and offers the repair button on the spot — no need to restart the app or contact support to figure out what's wrong.

Even if an unexpected error happens elsewhere in the app due to missing Windows files, Margin Master now recognizes the signature and shows the repair dialog instead of a confusing crash message.

The support script's documentation (`docs/marginmaster/support/scripts/install-dotnet-runtime.md` and the script's own `.md`) now explains the repair workflow, the startup check, and the title-bar pill. New search keywords: "repair dotnet", "runtime damaged", "missing assembly", "System.Threading.Tasks.Parallel", "vcruntime140_cor3", "corrupt runtime". The troubleshooting section covers what to do when antivirus keeps re-quarantining the file.

The missing-assembly detector moved from RowVersionTableSync (CloudSync layer) to a new FrameworkIntegrity class in Common, now shared by the WPF app's startup check, sync error handler, and global exception handlers. It walks the exception chain for FileNotFoundException, BadImageFormatException, and DllNotFoundException, filters to System.* / Microsoft.* assemblies and known shared-framework native libs (vcruntime140_cor3.dll, etc.), and provides a CheckCurrentRuntime() method that reads the process's own NETCore.App + WindowsDesktop.App deps.json manifests and stats every declared runtime/native file. RuntimeRepairService in the WPF layer orchestrates the UI (one dialog, one script runner, one main-window pill) for all detection sites.

A new `FrameworkIntegrity` class provides pure, testable functions for reading `.deps.json` manifests, checking files on disk, and detecting framework-load exceptions. The bulk-upsert engine's existing `FindMissingFrameworkAssembly` logic was moved here and extended to handle `DllNotFoundException` for native libraries (`vcruntime140_cor3.dll`). Detection now covers managed assemblies, native DLLs, and both the `Microsoft.NETCore.App` and `Microsoft.WindowsDesktop.App` shared frameworks.

No direct user impact—this is an internal documentation tool.

A new `--screenshot --manifest=<file>` launch mode starts Margin Master like a headless run (no mutex, no startup dialogs), shows the main window at a manifest-specified size on a pinned theme, opens each listed dialog or menu through view-model commands, captures it as a PNG, and exits. Manifests live in `docs/<category>/screenshots/` beside each doc and specify which screens to open (main window, Options tabs, Print dialog, effective-date picker, or drop-down menus), optional view-model method invocations, property overrides to hide real store identifiers, and crop rectangles. A PowerShell runbook (`Update-DocScreenshots.ps1`) builds Debug and runs the capture against a test database. Screenshots are deterministic across machines (visual captures render at a pinned DPI), version-controlled, and served by Manager for web/PDF/Word rendering.

Documentation pages now include actual screenshots from Margin Master showing exactly where to find features and buttons, with numbered callouts matching the text.

The Propello guide is now easier to follow with screenshots showing each step of setting up the connection, importing your data, and sending prices back to Propello.

Extended the screenshot manifest to support `command` targets (invoking any public MainMMViewModel method), highlight annotations with optional numbered badge labels (red rounded outlines that draw attention to specific fields), automatic prompt dismissal during dialog closure, and settle delays for windows that load asynchronously. Commands can run to completion for setup steps (e.g., refreshing the grid so later dialogs have data) or capture the dialog they open.

The Propello setup guide now has pictures showing exactly where to enter your Propello URL, username, and password, and where to click to import your data and send price changes back.

The error message when a DIB price file is missing now correctly refers to DIB files instead of Propello.

The "No DIB Price File Files Found" message now correctly reads "No DIB Price File (mbrxxxx.csv) Found" and instructs users to place "the DIB Member Retail Price File" in the import directory (was "Propello Export File").

Added automated screenshots to seven documentation guides: SQL Optimization (Help menu, Database Utilities menu, Missing Index Recommendations window, Maintenance Scripts dialog), Resetting Data (Utilities menu), System Diagnostics window, Issue Submission (Help menu, Support Issues window, Contact step), and SQL Server Tools window. Menu paths corrected throughout documentation to reflect actual application structure (e.g., maintenance scripts live under File > Database > Utilities, not Help > Database Utilities).

When `ScreenshotMode.IsActive` is true (set during screenshot startup), the What's New dialog, data-aging view, database rename prompt, and auto-update check are all suppressed so nothing modal lands on top of a capture. Startup checks still run to ensure a valid database and schema, but every dialog is headless-suppressed.

Replaced six placeholder SVG images in the MAP/IMAP pricing guide with real screenshots showing MAP Price and IMAP Price columns in the data grid (overview and close-up), Future Price panel with Ace MAP Price Amount selected, and the Data menu with "Update Ace Hardware Data" highlighted. Added screenshots to the Critical Retail Pricing guide showing the Strategy menu and configuration dialog with price mode toggle and comparison operators highlighted.

Help documentation now shows zoomed-in screenshots of specific buttons and fields right next to the text explaining them, with numbered circles matching numbered instructions.

Added 19 generated screenshots to 14 Pricing docs covering strategy manager, premade-strategy catalog, rounding editor and scheme check, custom groups, SKU exceptions, min/max strategies, cost breaks, Profit Analyzer, One Click Statistics, all three Future Price tabs, backup/restore pickers, wildcard selection, and lock column. Each screenshot is automatically captured from the running application using manifest files that script the UI, ensuring documentation stays current with the software.

Extended the automated screenshot system to support nested dialogs (a shot that invokes a method opening a further dialog now captures that nested window with `opensDialog: true`), dotted property paths for setting view model state (`"FuturePricePanel.SelectedTabIndexFuturePriceRounding": "1"` navigates child view models), screen-level `set` executed before opening dialogs, and per-shot `settleMs` delays for asynchronous content. Automatic strategy backup is now suppressed during screenshot runs to avoid uploading demo-store data to the cloud.

Updated 14 pricing documentation files with embedded screenshots, numbered highlight badges linking images to text legends, and metadata refresh. The `docs/index.json` search index and `CHANGELOG.md` now reflect the new screenshots. This builds on the Getting Started screenshot work from the previous release.

Enhanced the screenshot automation system to accept nested menu paths using slash notation (e.g., "mnuFile/mnuDatabaseManagement/mnuDatabaseUtiltities"). The harness now opens each menu level sequentially and properly closes them in reverse order, enabling automated capture of deeply nested menu structures.

Documentation screenshots are defined in JSON manifests committed alongside docs (e.g., docs/marginmaster/pos-systems/screenshots/propello.manifest.json). Each manifest specifies window size, render scale, screens to open (main, options tabs, dialogs, menus), view-model methods to invoke, placeholder property values (to avoid showing real store identifiers), and crop rectangles. Output must be a .png inside a screenshots/ folder—the runner refuses to write anywhere else. Conventions and technical details added to docs/CLAUDE.md.

Screenshot manifests are JSON files specifying window size, render scale, and a list of screens (each naming a target: `main`, `options` + tab name, `print`, `effective-date`, or `menu` + BarSubItem name). Shots can invoke public view-model methods (e.g. `ShowFieldHelp`), set properties (to show placeholders instead of real store identifiers), and crop. The runner refuses to write any file that is not a `.png` inside a folder named `screenshots`, preventing accidental overwrites elsewhere. Tests enforce this rule and validate manifests against incomplete or unsafe configurations.

Manifest validation ensures command targets name a method, highlights have positive dimensions and valid hex colors, and setup-only commands (those that run to completion without opening a dialog) are allowed to have zero shots. Visual and screen-mode captures both render highlights with anti-aliased outlines, badge circles, and centered bold labels over the captured pixels before applying crop.

Updated docs/index.json with new Propello guide structure (headings, body excerpt, keywords including "import propello data", "restore from cloud", "options"), docs/version-map.json source file tracking, and docs/CHANGELOG.md entry. Documentation last-updated dates refreshed to 2026-08-27.

Your store number will now be recognized correctly after upgrading from an older version.

If you had multiple stores using Compass with older Margin Master versions, your historical per-store inventory data will now properly migrate to the new unified format even on first-time database upgrades.

If you're upgrading from an older version with MySQL/Compass, your pricing data will now appear in the grid immediately after the upgrade instead of showing an empty table.

After upgrading, all your existing item data will now appear in the pricing grid immediately instead of showing an empty table.

Fixed the order of migration steps so that legacy store-number normalization runs before the storematchup table is read. Previously, a legacy 3.9.x store number stored as the raw POS character (e.g., "1") would be misinterpreted as ordinal 1 instead of the correct ASCII value 49, creating incorrect storematchup entries that would never match Compass data. This sequencing fix prevents the corruption from occurring during the upgrade.

On first launch or after a database upgrade, vendor catalog data now downloads automatically in the background. You'll see a status message on the splash screen but won't need to click Yes to continue.

When you first install Margin Master or reset your database, the vendor catalog will download automatically during startup instead of asking you to confirm. The splash screen will show "No [Vendor] data found — updating your vendor data now…" while the download completes.

After the first-time vendor data download, your pricing grid will now show up-to-date costs and retail prices immediately instead of stale data.

The startup screen now shows a clearer message explaining that your vendor catalog is being downloaded automatically.

When selecting your Primary Vendor, RSC, or POS System in Settings, you can now type the first letter (like "O" for Orgill) to jump directly to that option instead of clicking through the entire list.

Synchronous database connection loads on the UI thread now have a 10-second timeout limit. If the load lock cannot be acquired within this window, the system logs a warning and proceeds with loading to avoid UI stalls. This provides a safety mechanism against potential threading issues while maintaining normal fast-path performance.

The application will no longer crash with "Invalid object name" errors when switching between databases or during restore operations.

Added error handling to the background feature flag check that runs on a timer from the UI thread. During database restore or switching operations, settings reads can temporarily fail while the database is in transition. The flag now safely degrades to "disabled" rather than surfacing as an unhandled exception, preventing potential UI crashes during restore operations.

When the application performs a first-run vendor sync (automatically downloading vendor catalogs for an empty database), it now skips the subsequent shrink and index rebuild maintenance since those tables were just freshly created. This optimization reduces startup time on the slowest launch scenario a customer experiences—the very first time opening a new database.

When the first-run vendor sync rebuilds all main tables during startup, deferred database maintenance (shrink and index rebuild) is now skipped since those tables were just rebuilt seconds ago. This eliminates wasted time on the slowest launch customers experience. The once-a-day maintenance gate will run it on the next startup.

The pricing strategy loader now completes before database maintenance begins, preventing the "Shrinking database..." status message from being immediately overwritten by "Strategy loading completed." This provides clearer feedback about what operations are taking longer during startup.

The strategy loader now completes before deferred maintenance begins, preventing multi-minute "Shrinking database..." status messages from being immediately overwritten by "Strategy loading completed" messages.

The application will no longer freeze on the "Calculating Rounding Points" screen when restoring a database backup. The restore process now completes smoothly without requiring the application to be force-closed.

Restore-from-backup operations will no longer cause the application to freeze or hang when reconnecting to the database.

After restoring a backup, the application will now properly reconnect to the database instead of showing login errors or configuration screens.

Database restore operations now complete cleanly without triggering unexpected errors or configuration screens.

When opening Margin Master or switching databases, you'll now see a "Bringing this database up to date" message while necessary updates complete, instead of seeing an empty pricing grid that fills in later.

When opening Margin Master or switching databases, the pricing grid will now wait to appear until all necessary data is ready, eliminating the brief "No Items Found" message that previously appeared while vendor catalogs were being loaded.

The "Waiting for database to be ready" step after a restore now accurately reflects when the database is actually accepting connections.

The restore process now waits for the database to be fully ready before continuing, preventing connection errors.

The StoreManagerInfo migration (converting legacy per-store POS mapping to the unified table) only ran during cold startup, meaning switching to a legacy database via the watcher or menu never converted it. This migration now runs through RunDatabaseReadyChecksAsync, which both startup and ReinitializeForDatabaseChangeAsync reach, so a switch to a legacy database converts exactly like a cold start.

Fixed an issue where database maintenance operations (index rebuilds and shrinking) started on one database could continue running against a different database after switching. The application now waits for any in-flight maintenance to complete before switching databases, preventing maintenance commands from landing on the wrong database. Wait time is bounded by the shrink operation's 600-second timeout.

Database maintenance (shrink and index rebuild) could start on one database and finish its index pass on the next database after a switch, because the task ran asynchronously without tracking. The maintenance task is now stored in _deferredMaintenanceTask, and ReinitializeForDatabaseChangeAsync waits for it to complete with a "Waiting for database maintenance to finish..." message before switching databases.

Added ConfigureAwait(false) to all async operations in the database connection service to prevent unnecessary context switching and reduce the risk of dispatcher-related deadlocks. This follows best practices for library-style code that doesn't require UI thread affinity.

Implemented a 10-second maximum wait time for synchronous database connection loads. If the lock cannot be acquired within this timeframe, the system logs a warning and falls back to a direct load operation. This ensures that any future regression degrades gracefully to a logged warning rather than a frozen application.

If you leave an Epicor import paused overnight and the system runs an automated import, the system will now download fresh data instead of potentially freezing.

The EpicorFTPFileExtractorService has been relocated to the MarginMaster.DataImport library as part of ongoing modularization. The service now uses interfaces (IImportDatabaseService, IApplicationSettingsService) instead of concrete dependencies, enabling better separation and reuse across different host applications including the WPF desktop app, background services, and diagnostic tools.

DatabaseService now implements IImportDatabaseService directly through explicit interface members (DatabaseService.ImportSeam.cs), allowing DataImport-side services to accept the interface while WPF callers continue passing DatabaseService unchanged. The existing adapter remains for dependency injection scenarios. This eliminates an unnecessary wrapper layer while maintaining compatibility.

MessageRotator and SqlTransientRetry (now public) have been moved to MarginMaster.Common along with their tests, making them available to the DataImport library and other components. StoreManagerInfoWriter and EpicorConnectionFailureMessage were moved to DataImport as they're required by the Epicor extractor service.

After restoring a strategy backup, the completion message now tells you exactly what came back—such as "Restored 11 rule steps, 3 custom groups, and 53 SKU exceptions for: 05598-PS_imported." If no rules were restored, you'll see a warning explaining why and what to check.

If you run a strategy and no prices change, the summary now explains why—such as "The active strategy 'DEFAULT' has 1 rule(s), but none of them matched any item. Another strategy in this database does have rules: '05598-PS_imported'. If that is the one you meant to run, select it in the strategy list first."

The strategy execution summary now highlights when no prices were changed and suggests which strategy you should use instead.

When you restore a strategy backup, Margin Master now tells you exactly how many rules, custom groups, and exceptions were actually restored, and warns you clearly if nothing was brought back.

If you run a pricing strategy that changes nothing, Margin Master now explains why and tells you which other strategy contains your actual rules, turning a support call into a two-click fix.

Restoring the same backup file multiple times no longer creates duplicate copies of your pricing rules and settings.

Restoring the same strategy backup multiple times now works correctly—it won't create duplicate copies of your strategy rules.

The summary screen after running a strategy now includes a warning section at the top if no prices were changed, explaining why and what to do next.

Unified three copy-pasted completion message blocks (local file restore, cloud restore, legacy file restore) into a single ShowStrategyRestoreCompleteMessage method that cannot drift apart. All three entry points now use the same logic to report what was actually restored.

Introduced BackupRestoreResult model to capture what a restore operation actually wrote (strategies, steps, groups, exceptions) rather than inferring success from the backup file's contents. All restore code paths (local file, cloud, legacy formats) now return this detailed result, enabling accurate user-facing reporting regardless of which options were selected or which per-strategy skip logic applied.

Added EmptyStrategyRunNotice helper class to generate consistent user-facing explanations for strategy runs that changed no prices. The helper queries for other strategies with rules and produces messages like "The active strategy 'DEFAULT' contains no pricing rules. Another strategy in this database does have rules: '05598-PS_imported'. If that is the one you meant to run, select it in the strategy list first."

The TypeMismatch schema difference now records ModelIsNullable and DatabaseIsNullable fields, matching the pattern already used by NullabilityMismatch. When model nullability is unknown, the generator falls back to the database's current nullability to make the ALTER statement nullability-neutral, and only when both are unknown does it choose the non-destructive NULL direction. This ensures that "unknown" never means "tighten."

When tightening a nullable column to NOT NULL, the generated UPDATE statement that clears existing NULLs now uses a default literal appropriate for the column's current type rather than the model's target type. The scrub runs before the ALTER COLUMN executes, so writing an empty string into an int column would have been silently converted to 0 rather than the intended empty value. A new SchemaColumnSql helper class centralizes this logic for both TypeMismatch and NullabilityMismatch scenarios.

The application will start faster since database schema commands only run once instead of repeating on every launch.

Extended the schema update validation logic to recognize both ALTER TABLE and UPDATE commands when determining if they target a view. Previously, only ALTER TABLE commands were checked, allowing NULL-scrub UPDATE statements to fail repeatedly. The validation now correctly identifies all commands that target table-like objects and verifies their applicability.

Columns that were incorrectly tightened to NOT NULL by previous versions will automatically heal on the next startup. With ModelIsNullable now properly populated, the comparer detects model-nullable-vs-database-NOT-NULL as a NullabilityMismatch and generates the corrective ALTER COLUMN NULL statement.

Fixed a database schema issue that could cause startup errors or prevent certain fields from accepting empty values.

Database updates will no longer fail when column types need to change, preventing startup errors that previously blocked the application from running.

Database updates no longer fail repeatedly at startup when vendor data views are present in the database.

Database schema updates that previously failed repeatedly during startup will now complete successfully.

When the database schema needs to change a column from optional to required, existing empty values are automatically filled in so the update can complete successfully.

New database columns are now added successfully even when your database contains existing transaction data.

Startup diagnostic logs will no longer show repeated schema update failures for vendor data tables.

NULL scrub statements now use the column's existing database type to generate the replacement literal, rather than the model's target type. This prevents silent type conversions where writing an empty string into an integer column would be converted to 0 instead of the intended empty value.

Extracted nullability clause and NULL scrubbing logic into a new SchemaColumnSql helper class with comprehensive unit tests (130 lines of test coverage). Both the TypeMismatch and NullabilityMismatch code paths now use the same tested logic, ensuring consistent handling. Unknown nullability now falls back to the database's current state rather than incorrectly defaulting to NOT NULL.

Added 27 new unit tests in SchemaColumnSqlTests covering nullability clause generation, NULL scrubbing logic, default literal selection for all SQL types, and edge cases like unknown nullability states. Full test suite now has 1,871 passing tests.

Implemented a complete resumable upload system that breaks large files into 8 MB blocks and tracks which blocks have already been uploaded to Azure. When a connection drops mid-upload, the next attempt scans Azure to identify which blocks are already staged and only sends the missing ones. Azure retains uncommitted blocks for seven days, allowing uploads to resume even after connection failures. The system uses deterministic block IDs based on file offset and upload tag to ensure blocks from different attempts of the same file can be correctly matched and assembled.

When attaching large files to support tickets (especially database backups that can take hours), if the upload is interrupted you can simply retry and it will pick up where it left off instead of starting from zero.

Long-running uploads now proactively renew their Azure credentials before they expire, using the server's clock to measure and compensate for clock skew on the store PC. The refresh buffer is now proportional to upload duration rather than a fixed five minutes, preventing uploads from failing halfway through with expired credentials. When Azure refuses a credential, the cached token is immediately invalidated so retries fetch a fresh one instead of reusing a poisoned entry.

Upload failures are now classified into credential issues (403, authentication errors), transient conditions (timeouts, 429, 5xx errors), and fatal errors (invalid requests, missing containers). Transient failures retry automatically with exponential backoff and jitter to prevent concurrent blocks from retrying simultaneously. Credential issues trigger automatic SAS token renewal. Fatal errors stop immediately with clear error messages rather than wasting time on futile retries.

The upload status now shows transfer rate, time remaining, and—most importantly—how many bytes were resumed from a previous attempt. Database backup uploads display human-readable progress ("4.5 MB/s - 38 min left - 500 MB already uploaded") instead of just a percentage, giving users meaningful feedback during multi-hour transfers.

Upload status now shows transfer speed, time remaining, and how much data was already uploaded when resuming an interrupted upload.

Failed blocks are now retried up to eight times with exponential backoff and jitter (starting at 2 seconds, capped at 60 seconds). The system distinguishes between transient failures (network timeouts, server errors) that warrant retry, credential problems that need a fresh token, and fatal errors (missing container, invalid request) that should stop immediately. This prevents wasting time on hopeless retries while recovering from temporary connection issues.

The client now learns the server's clock time with each SAS token response and calculates local clock skew. This prevents store PCs with incorrect clocks from treating valid tokens as expired (if running fast) or continuing to use expired tokens (if running slow). SAS tokens are also refreshed proactively based on expected upload duration rather than waiting for a 403 response mid-upload.

Each resumable upload opens a server-managed slot that assigns a unique blob name and block ID format. The slot is cached by issue ID, file path, file size, and last-modified timestamp. Retrying the same file reuses its slot (enabling resume), while a recreated database backup at the same path correctly gets a fresh slot to prevent assembling mismatched blocks.

Azure SDK blob client network timeout increased from the default 100 seconds to 10 minutes, with exponential retry configured. This prevents legitimate slow transfers on store uplinks from timing out prematurely, especially for 8 MB blocks on connections with intermittent packet loss.

The uploader now explicitly checks whether the server supports resumable uploads (via 404/405 responses) before falling back to the legacy direct-upload path. When a server understands the slot request but declines it (e.g., file over size limit, expired token), the real error message is preserved instead of being replaced by a different error from the fallback path. This fixes cases where a 466 MB backup was reported as "over the 128 MB limit" when the actual problem was an expired credential.

New upload slot endpoint requests are classified by UploadPathDecider: 404/405 responses fall back to the legacy upload-target path (non-resumable but functional), while understood refusals (expired token, file too large, missing issue) report their actual error rather than silently switching paths. This prevents MM-492-style misdiagnosis where an authorization failure on the resumable path fell through to a different path whose unrelated size limit complaint became the user-facing message.

Fixed a critical bug in AzureBlobService where short file reads would stage blocks padded with trailing zeros, producing database backups that were the correct length but silently corrupt—invisible until someone tried to restore them. The uploader now stages only the exact bytes returned by each read operation.

Fixed progress calculations that truncated instead of rounding up block counts, causing progress bars and ETAs to run against a denominator that was one too small. Also fixed SupportIssuesViewModel showing percentages calculated from file counts instead of bytes, driving the progress bar to 2500% when uploading two files.

Added InvalidateToken method to IBlobAccessService. When Azure refuses a credential, the cached token is immediately evicted so the next request mints a fresh one. Previously a poisoned cache entry would remain until it expired naturally, causing every retry to fail identically until the expiration window passed.

The Submit Issue dialog now displays detailed upload progress including phase name, transfer rate, estimated time remaining, and resumed byte count during attachment uploads. The status text adapts to each phase (Preparing, Scanning, Staging, Committing, Verifying, Registering) rather than showing a percentage alone during non-transfer phases.

Introduced IResumableBlobUploader interface and ResumableBlobUploader implementation in MarginMaster.Common with supporting types: BlobUploadProgress, BlobUploadOutcome, BlobUploadPhase, BlobUploadFailureKind, ResumableUploadRequest, BlobSasLease, ResumableBlockPlan, BlobRetryPolicy, and UploadPathDecider. These enable testable, pure functions for planning, retry decisions, and outcome classification separate from I/O concerns.

Added five test suites (2,614 lines total) covering retry classification, block ID agreement with the server, resume reconciliation, progress adaptation, and upload path decisions. The block ID tests use golden vectors copied verbatim from the server's own tests, ensuring the client and server implementations stay synchronized—critical because a disagreement silently commits blobs assembled from mismatched blocks.

Added extensive unit tests pinning retry classification logic, exponential backoff calculations with jitter, block ID format agreement with server (golden vectors), block plan arithmetic, resume reconciliation, upload slot identity rules, and progress adapter behavior. These tests prevent silent correctness regressions that would corrupt uploaded blobs by assembling mismatched blocks.

Configured BlobClientOptions throughout the application for the first time—previously every blob operation ran on the SDK's default 100-second network timeout. Network timeout is now 10 minutes with exponential retry (3 attempts, 2-30 second backoff), appropriate for large blocks on slow or intermittent store uplinks.

The Import Manager now better distinguishes between different types of database errors during vendor data updates. Previously, both permanent structural errors (like missing columns or tables) and exhausted retry attempts were reported identically, making troubleshooting difficult. Error messages now acknowledge that the detailed cause has already been logged and direct support teams to the correct log entry rather than suggesting an incorrect root cause.

When a vendor data update failed during import, the error message incorrectly claimed "Retrying did not resolve the timeout" even when the actual problem was a structural SQL error (such as a missing table) that was never retried. The system now accurately reports the failure and directs users to check the log for the specific cause. This corrects misdiagnosis issues encountered at stores 3174 and 3875, where investigators were looking for non-existent timeout problems when the real issue was SQL errors like missing database tables.

The previous implementation caused a single bug to generate 78 of 84 distinct error groups in seven days because each SKU produced its own error signature. By using a parameterized query with constant SQL text, all errors now collapse into a single fingerprint, dramatically reducing log noise and making real issues easier to identify.

Even if your store was renumbered in the past, the system will detect and fix any mismatched table names the next time Margin Master starts.

The orphaned table check now runs on every single-store sync pass rather than only when a renumber occurs. This ensures databases where metadata was already repaired days or weeks earlier will still have their orphaned tables corrected, matching the real-world scenario where the issue was reported after the repoint had already completed.

When a SKU has no vendor GTIN barcode data, label printing falls back to reading the UPC from the Store table. The previous query selected the entire Store row into a data structure that expected OrderMultiple to be an integer, but on 168 of 170 live databases that column contains text values like "1.00". This caused Dapper to throw a mapping error for every row. The query now reads only the UPC column as a string, eliminating the type mismatch. Additionally, the SKU is now passed as a parameter rather than interpolated into the SQL, which prevents each SKU from creating its own unique error fingerprint in logs.

Label printing will now work reliably even when UPC codes need to be looked up from your store's inventory data, fixing crashes that could occur when printing multiple labels at once.

If your store was renumbered, the main pricing table will now automatically update to use the new store number instead of keeping the old one, and the store selection dropdown will show only the correct current number.

If your store number changes, the pricing table automatically updates to the new number so you won't see your old store number appearing in dropdown lists.

Added a LEN >= 2 check in the WHERE clause to ensure the UPC value is long enough before slicing it with [2..], preventing potential index out-of-range errors. Previously this was implicitly handled by a catch block that has now been removed.

After renaming a per-store main table, the StoreNumber column in every row is updated to the new number and SelectionLists is cleared to force regeneration. Without this, the store selector would continue reading the old number from the column data even after the table was renamed.

When a per-store main table is renamed, any managed indexes are dropped and removed from the ManagedIndexes registry, then recreated under the new table name. This prevents carrying stale "RSIX_9645_*" indexes on a table now named for store 19532, which would impact query performance.

The rename operation includes several safety checks: refuses to act unless there is exactly one orphaned table candidate, verifies the target table name is available (won't overwrite an existing table), uses a rename lock to prevent concurrent operations, and reuses the existing rename sequence for leading-zero fixes. Also drops and rebuilds RSIX indexes to prevent stale index cost.

The rename logic includes multiple safeguards: it only renames when exactly one candidate table exists, refuses to rename if a table already exists under the target name, and ignores StoreGroup compound tables or other POS systems' tables. These checks ensure automatic renames never destroy data when the database has multiple per-store tables or other ambiguous conditions.

When a file successfully uploads to Azure blob storage but fails to register against the support ticket, the response now includes the blob name. This allows future retry logic to re-register the existing blob rather than re-uploading a multi-gigabyte file.

The application now reads upload size limits from the server instead of using hardcoded values. This allows the server to advertise its actual multipart body limit (which increased from 128 MB to 256 MB in recent versions) and ensures older clients don't incorrectly reject uploads that newer servers can handle.

The maximum file size for the legacy multipart upload method is now retrieved from the server rather than using a hard-coded client constant. The 128 MB constant remains only as a fallback for older servers that don't advertise their limit. Non-positive values are treated as "not advertised" rather than "nothing allowed."

Removed the DeleteIfExistsAsync call before blob uploads, which was discarding staged uncommitted blocks and destroying Azure's ability to resume interrupted transfers. The UploadAsync method already overwrites existing blobs by default, so the delete was unnecessary and harmful for large multi-gigabyte files.

Removed pre-upload blob deletion that was destroying Azure's uncommitted block tracking. Large multi-gigabyte uploads can now properly resume from partial progress if retried, rather than restarting from zero every time.

Changed the error message shown when vendor catalog updates fail to avoid incorrectly naming "timeout" or "retries" as the cause. The underlying database operation returns the same error code for both structural database errors (like a missing table) and genuine timeouts, so the application cannot distinguish between them. Now the message directs users to check the detailed log for the actual cause rather than making an incorrect assumption. This change was prompted by two support investigations (stores 3875 and 3174) where the message incorrectly blamed timeouts when the real issue was a dropped database table.

When attaching large files to support tickets fails, you'll now see the real reason (like "connection timed out" or "credentials expired") instead of always being told the file is too large.

When a large file upload to support fails, the error message will now tell you the real reason (like "upload location expired" or "server unavailable") instead of incorrectly saying the file is too big.

Stores that don't have dedicated cloud storage can now successfully upload large files to support tickets (this was broken and always failed with a size error).

Support file uploads now work correctly for all stores, including those without dedicated cloud storage containers.

Added detailed warning logging when VendorGTIN or Store table UPC lookups fail during label printing. The system now logs the specific SKU and exception details, making it easier to diagnose why individual labels might print without barcodes.

Fixed an issue where labels would print without any barcode when certain products were missing vendor information. Now barcodes print correctly by looking up the UPC from your store's product data.

Reverted PR #1334 which attempted to fix a data exception when printing labels by reading only the UPC column from the Store table. The fix inadvertently caused issues, so the system has been returned to the previous UPC fallback implementation that queries the full Store record when VendorGTIN lookup fails.

Label printing now uses the original UPC lookup method. When generating barcodes for labels, the system first checks VendorGTIN, then falls back to the Store table UPC field, using the previous query approach.

The database service now logs the complete SQL error message (including table and column names) when encountering structural errors like missing tables or columns, rather than truncating to a generic preview. This ensures diagnostic telemetry captures the full context needed to identify which specific object is missing.

When vendor data updates fail, the error message now tells you to check the log for specific details instead of always blaming a timeout.

Sync error logs now include the full exception details with stack traces instead of just error messages. This ensures connectivity issues like SQL Server timeouts are properly recorded in telemetry for support diagnosis, preventing scenarios where errors appeared as "Unknown" type with no diagnostic information.

If your database server stops responding during sync, you'll now see one clear message saying "a server could not be reached" instead of multiple confusing error messages for each table being synced.

Cloud sync now uses the same SQL error classification logic already tested and proven in the POS import system, ensuring consistent handling of connectivity issues across the application. Added test coverage to prevent genuine sync defects (missing tables, columns, deadlocks) from being misclassified as connectivity problems and suppressed from error telemetry.

Error messages during sync are now more accurate about which server couldn't be reached, helping you troubleshoot the right system.

Margin and price fields now display consistently throughout the application.

Added logic to correctly interpret DevExpress numeric mask scaling rules: predefined "p" (lowercase) divides by 100 while "P" (uppercase) does not; bare "%" in custom masks divides by 100 while "%%" or "\%" do not. Currency ("c2") and plain number ("n2") masks are correctly identified as non-scaling. This ensures the spinner increment adjustment applies only to true percent masks and not to fields like Future Price → Margin % which use an escaped literal percent sign.

Implemented logic to detect when a numeric mask scales the displayed value differently from the stored value. The system now correctly identifies that lowercase "p" masks and bare "%" symbols in custom masks scale by 100x, while uppercase "P", escaped "\%" literals, and "%%" sequences do not. This ensures spinner increments are calculated in the correct value space.

Split increment resolution logic into ResolveExponent and Pow10 functions, with CaretIndexForExponent as the inverse operation. This allows the system to restore caret position by place value (ones, tenths, hundredths) rather than character position, maintaining correct behavior when formatted text grows or shrinks.

Replaced the MMNumericEdit custom control with NumericEdit.CaretAware and NumericEdit.FormatMode attached properties that work on standard SpinEdit instances. This architecture allows any spin editor in the app to opt into caret-aware behavior via XAML attributes without breaking DevExpress theme rendering.

When you're editing a margin percentage or dollar amount and press the up or down arrow (or use the mouse wheel), the number now changes at the digit where your cursor is blinking, not always by whole numbers.

Margin %, Fixed Retail, and Manual amount fields now display correctly instead of appearing blank.

Margin percent and fixed retail price editors now display correctly instead of appearing as blank boxes.

When using the up/down arrows on Current Margin and similar percent fields, the value now changes by the expected amount (like 0.10%) instead of jumping by 10 full percentage points.

When you click the up or down arrow buttons on percent fields like Current Margin, the value now changes by the correct small amount (like 0.1%) instead of jumping by a full 10%.

Holding the Up or Down arrow key now consistently steps the same digit instead of jumping around.

Holding down the Up or Down arrow key now repeatedly steps the same digit instead of jumping to different digits each time.

When you click into a margin or price field and use the up/down arrow keys or spinner buttons, only the digit where your cursor is positioned will change—making it much easier to fine-tune prices to the nearest cent or tenth of a percent without retyping the entire value.

Updated the Margin % and Fixed Retail spinners in the Future Price Panel to use MMNumericEdit with FormatMode="Percent" and FormatMode="Currency" respectively. Removed the attached behavior markup in favor of the control's built-in functionality.

MMNumericEdit introduces a FormatMode property with presets for Currency, Percent, and Number formats, automatically stamping the appropriate mask and format settings. FormatMode defaults to Inherit so existing call sites that assign Mask from code-behind (like UC_MMCostSelectionBox) continue to work unchanged. The Percent preset uses a literal "%" suffix rather than a P-mask to avoid the 100x scaling issue—margin is stored in percentage points throughout the application.

Updated UC_MMSelectionBox and UC_MMCostSelectionBox to use MMNumericEdit with FormatMode="Inherit". These controls assign their masks from bindings or code-behind at runtime, so the Inherit mode preserves that behavior while adding caret-aware stepping.

All numeric input fields in Future Price calculations and item selection now work consistently.

Migrated editors in UC_MMCostSelectionBox (range From/To fields), UC_MMSelectionBox (specific value field), and FuturePricePanel (margin percent and fixed retail editors) from the now-removed MMNumericEdit tag to SpinEdit with NumericEdit.CaretAware and NumericEdit.FormatMode attached properties. Functionality remains identical but rendering now works correctly.

Converted the CaretAwareSpinBehavior attached behavior into MMNumericEdit, a SpinEdit subclass. This simplifies XAML (no longer requires explicit Interaction.Behaviors tags), improves testability (the control exposes its increment resolution logic as a static method), and provides a cleaner extension point for format presets. The control inherits SpinEdit's default theme style so it renders identically to standard editors while adding the caret-aware increment calculation in the Spin event handler.

Added comprehensive test cases covering all DevExpress mask types including "p2", "P2", "#,##0.00%", escaped literal "\%", currency, and number formats to verify the display scale calculation returns 100 for rescaling masks and 1 for non-rescaling masks. Includes hands-on verification test that a "p2" editor configured like Current Margin now steps by fractions (≤0.01) instead of whole percentage points.

Added MMNumericEditTests and MMNumericEditIncrementTests with 16 test cases, expanding on the 7 cases the old behavior tests covered. New tests pin DevExpress assumptions the control depends on (that Increment assigned during the Spin event is applied, that fractional increments survive), verify that negative signs and decimal separators are handled correctly, confirm that FormatMode presets stamp the expected masks, and ensure the Percent mask is a literal suffix rather than a scaling mask.

Added 15 test cases covering caret position resolution, including edge cases like negative numbers, caret on decimal separator, deep fractions, currency symbols, group separators, and text with no digits. Verified that DevExpress SpinEdit respects Increment assigned during the Spin event and that fractional increments survive the spin operation.

Added comprehensive unit tests for the new caret position restoration algorithm, including round-trip verification that a caret index for a given place value resolves back to the same exponent, and that the caret correctly follows digits when text length changes (e.g., 9.99 becoming 10.00).

The store identity repair process now detects and logs a warning when the vendor configured in application settings contradicts the vendor recorded in the database's About table. This mismatch can occur when a failed-over license answer writes another company's identity into settings. The repair correctly refuses to proceed (preventing data corruption), but now explicitly logs the conflict with both vendor names and instructions to correct it manually in Store Configuration. Previously, this protective refusal was silent, making the issue impossible to diagnose from logs.

Added warning-level logging to both the vendor GTIN lookup and Store UPC fallback paths. Previously, exceptions were silently swallowed, making it impossible to diagnose why certain labels printed without barcodes. The new logging will surface these issues in diagnostic reports, helping identify data quality problems before they affect label printing.

The fail-fast message when sync cannot reach a server no longer incorrectly states "Manager API unreachable" in cases where the local SQL Server is the actual problem. It now says "a server could not be reached" to avoid sending users to investigate the wrong system.

When opening a store's SKU-level exceptions, you'll now see exactly how many have loaded, the percentage complete, and how much time is left—so you know the system is working and not frozen.

Three sync logging points that previously omitted exception details now include full stack traces: per-table failures, SQL timeout errors, and the summary when multiple tables fail. This ensures diagnostic information reaches error telemetry instead of appearing as "Unknown" exception types.

The SKU-level exceptions window now opens in seconds instead of minutes, even for stores with thousands of exceptions.

If a product didn't have vendor catalog information, its label would print without a barcode. This is now fixed—labels will show the correct barcode from your store's product data when vendor information is missing.

If your SQL Server becomes temporarily unavailable during cloud sync, you'll now see one clear warning message instead of multiple confusing errors.

Closing the SKU-level exceptions window is now instant, even after working with thousands of exceptions.

The Save button now lights up correctly when you change a rounding scheme on the SKU-Level Exceptions screen.

Labels with unusually short UPC codes will now print reliably instead of potentially failing.

Confusing Apply and "Save" buttons that did nothing have been removed from the Future Price panel's Rounding and Advanced tabs in the SKU-Level Exceptions window.

The progress bar now fills smoothly as SKU-level exceptions load, giving clear visual feedback.

The SKU-level exceptions grid now sizes its columns instantly, even with tens of thousands of exceptions loaded.

After changing the rounding scheme for multiple SKU exceptions at once, the Save button now becomes available immediately so you can save your changes.

When loading SKU-level exceptions, you'll now see exactly how many have loaded, the percentage complete, and how much time is left, instead of a frozen progress screen.

The Future Price panel in SKU-level exceptions no longer shows misleading "Save" buttons that don't work—use the Save button at the top of the window instead.

Opening a store's SKU-level exceptions now takes seconds instead of minutes, even when there are tens of thousands of exceptions to display.

Added validation logic to distinguish between benign "nothing to do" scenarios and actual vendor contradictions during store identity repair. The system now treats Ace Hardware and Emery Jensen as the same vendor family (since EJ stores are carried as Ace in vendor tables), and recognizes Unknown vendor values as non-contradictions to avoid false alarms for pre-About databases. No behavior changed—repairs that previously succeeded still succeed, and repairs that were refused are still refused, but contradictions are now visible.

The cloud sync engine now delegates SQL connectivity failure detection to the same curated error-number list already used by POS imports (including error 258 for network unavailability), ensuring consistent behavior across the application and preventing divergent maintenance of duplicate logic.

The SKU-Level Exceptions grid no longer freezes for several seconds after loading when there are many exceptions.

The system now logs the total time and row count for each SKU-level exception load operation, providing diagnostic data for performance monitoring and future optimization efforts.

Added detection and logging for cases where the vendor configured in Store Configuration (e.g., Ace Hardware) contradicts the vendor recorded in the database (e.g., Do-It-Best). This condition was previously detected and correctly refused for safety reasons, but the refusal was silent, making customer issues impossible to diagnose from logs. The system now logs a clear warning message when this contradiction is found, directing the user to correct the vendor in Store Configuration. The safety behavior is unchanged — the system still refuses to automatically overwrite store identity when vendors conflict.

Resolved a specific diagnostic gap (MM-1393) where a failed-over license could write an incorrect vendor into application settings, leaving the application configured for one vendor while the database belonged to another. This state was correctly refused by the automatic store-renumber repair, but produced no log output, preventing support from identifying the root cause. The new logging makes these cases immediately visible in customer logs.

Replaced a file-existence probe (which was true for every BisTrack store) with a run-scoped flag (`BuiltMainTablesDuringIngest`) set only by the two BisTrack CSV preload builds. Those handlers use a custom SQL script that is not column-equivalent to the generic rebuild—it writes different columns (Lock, PSRule, Discontinued) and computes StoreCost and CMargin differently—so the rebuild must leave their tables untouched to avoid silently changing customer data.

Selection boxes (vendor, category, etc.) will no longer go blank if a background import runs while you're using Margin Master.

The SelectionLists table (which populates dropdown selection boxes) is no longer truncated mid-ingest, preventing the UI from showing empty dropdowns when a background import runs while the app is open. The rebuild process now owns this cleanup step, performing it at the appropriate time.

If a background import runs while you're using Margin Master, your pricing grid and selection boxes will no longer be cleared. All table rebuilds now happen during the post-processing step that waits until you close the app or click OK.

BisTrack Direct SQL was the last POS system whose ingest destroyed and rebuilt its own main tables before the post-processing rebuild could run. The table build is now handled by the standard rebuild process, using the same SQL builder against the same Store rows the ingest loads. This prevents the app from dropping pricing tables while open with a background import in progress—a scenario that previously left stores with no main tables at all.

If one store has a configuration problem during import, the other stores will still complete their imports successfully.

When a single store's RSC lookup failed during main table rebuild, the entire import run would stop with a modal error, silently skipping all remaining stores. This was particularly problematic for unattended background runs. The rebuild now logs the error, reports the affected store in the post-import summary, and continues processing remaining stores.

When importing selected Epicor stores (Shift-click), stores you didn't select will keep their pricing data instead of being cleared and left empty.

Dropdown menus in the pricing grid will no longer go blank during a background import.

BisTrack Direct SQL imports previously built per-store main tables during the ingest phase, which could leave stores without main tables if a background import ran while the app was open and the subsequent rebuild was deferred indefinitely. The import now loads only the [Store] staging tables and lets the unified rebuild process create main tables using the same generic SQL builder as other POS systems. This fixes edge cases like store 16254 ending up with no main tables at all.

Introduced PosMainTableOwnershipPolicy to explicitly define whether the ingest or rebuild phase builds each POS system's main tables. Almost all POS systems (Epicor, Mi9, Falcon, RockSolid, TransAct, Propello) now use rebuild-owned tables. Only BisTrack and WestLake remain ingest-owned because their drain logic does not yet rebuild their tables. The policy includes fail-safe tests to prevent new POS systems from accidentally inheriting ingest-owned behavior.

The two BisTrack CSV preload paths (standard and DIB 6828 format) use a specialized SQL script that computes columns differently than the generic rebuild process. These handlers now set an explicit flag indicating they built the main tables, replacing a file existence check that incorrectly applied to all BisTrack stores including Direct SQL. This ensures the rebuild correctly skips or processes main tables based on what actually happened during ingest, not POS type assumptions.

Added PosIngestOwnsNoMainTablesTests to mechanically enforce that ingest-layer code does not touch main tables or SelectionLists. The test scans all files in the ingest services directory and fails if any unauthorized file contains main table DDL or SelectionLists truncates. An explicit allowlist documents the four remaining files that still build tables (BisTrack, WestLake, and their supporting code) with reasons why each exception exists and what needs to happen to remove it.

Stores scheduled before the vendor publishes will now automatically catch up mid-morning with a quick vendor-only sync (seconds), instead of waiting until the next overnight run.

If your nightly sync runs before vendors publish (most stores do), you'll now automatically get the current catalog mid-morning without waiting until the next night, and it won't re-import your POS data.

When you open Margin Master after the background service updated your data overnight, you'll see a green badge and a notification confirming the update happened and when.

Margin Master now tracks exactly what vendor data you have, not just when you last synced. If you reset your data or restore a backup, the sync will run normally without a prompt.

When new data downloads in the background, an amber "Click to update data" badge appears at the top of the screen. Click it when you're ready—you'll be asked once whether to run your pricing strategy too, then the data updates and your grid refreshes. The app no longer closes and restarts, so your session stays open.

When new pricing or catalog data downloads in the background, you'll see an amber badge at the top of the screen. Click it when you're ready to load the new data—the app stays open and shows progress just like a manual import.

Run history now clearly shows when new data has been downloaded but is waiting for you to apply it, instead of reporting "completed" when the tables haven't been rebuilt yet.

Added VendorPublicationCutoffTime setting (format "HH:mm", default 09:00) so support can adjust the cutoff for stores in unusual timezones or when vendor publication timing drifts. Unparseable values fall back to the default rather than throwing—a typo in a setting must not stop a store from syncing. Erring late is the safe direction; a cutoff set too early would close the guard on a sync that ran before the catalog was finished.

Support can now adjust when the system expects vendor catalogs to be published, if your region's timing differs from the 09:00 default.

Introduced --vendor-only command-line switch for headless data updates, which drops the POS import leg and fetches only vendor catalogs. Used by the post-publication catch-up to avoid redundant full POS imports. Recognized in all spellings (--vendor-only, --vendoronly, /vendor-only, case-insensitive).

The pricing strategy rewrites FuturePrice across the main tables and ran unflagged, so an app starting up mid-strategy could open onto half-written prices. The background runner now brackets the strategy phase with SetStrategyPhaseDestructiveAsync so concurrent startups wait rather than binding to incomplete data. The drain already brackets itself; this closes the gap for the strategy leg that runs after the drain has cleared its own flag.

The Background Jobs history now clearly shows when data was downloaded but not yet applied, making it easier to understand your store's current state.

If your store syncs early in the morning (before ~9 AM), you were getting yesterday's catalog and staying a day behind. This is now fixed—the system knows when catalogs are published and waits for them.

Clicking the badge after a background update now reloads the grid with the new data, not just the filter dropdowns.

If your computer restarts or Margin Master closes unexpectedly while a background update is waiting, the next scheduled update will now complete automatically—your data stays current without manual intervention.

Background updates now resume correctly after a reboot or unexpected shutdown, even if a previous update was waiting to be applied.

If your store syncs early in the morning before vendors publish their catalogs, the system now correctly recognizes when you need to fetch the day's catalog instead of treating yesterday's data as current.

The scheduled background update will no longer interrupt you to rebuild vendor data that hasn't changed since the last sync.

A new VendorSyncFingerprint captures the row count and highest RowVersion of each synced vendor table and is written alongside the sync timestamp. Comparing the recorded fingerprint to the current state detects when data changed underneath a stored timestamp — such as after Reset All Data, a database restore, or external edits — and reopens the guard automatically. The fingerprint is measured in 41-242ms on real customer databases and is cheap enough to run on every sync and every service tick.

The existing fingerprint-based evidence check (comparing recorded vs. current table row counts and checksums) is untouched and still required alongside the timestamp. This is what reopens the guard after Reset All Data or a restore-from-backup, where the timestamp alone would lie and suppress the most-needed sync.

If you click Update Vendor Data and you already synced earlier today, Margin Master will ask "Are you sure?" before downloading the catalog and rebuilding your tables again.

The activity badge color tells you what clicking it will do: blue means a background job is running, green means the data is already loaded (quick refresh), and amber means new data is ready to apply (takes a few minutes).

When you manually sync vendor data that's already current, the confirmation message now clearly shows when you last synced and confirms you already have the latest catalog.

When manually syncing vendor data that's already current, the confirmation now shows exactly when you last synced (date and time) and explains that you already have the latest published catalog.

A new ApplicationSettingKey.SyncVendorDataFingerprint stores the vendor data fingerprint alongside the existing SyncVendorData timestamp. The two are written together atomically in RecordVendorSyncSucceededAsync after every successful vendor sync, whether interactive or headless, and are read together to evaluate the guard.

Added VendorCatchUpLastRunDate application setting to store the local date the catch-up last ran, ensuring it fires at most once per day even across service restarts. An in-memory flag would allow a restart to re-trigger the catch-up on the same day.

Removed the `--rebuild-and-restore` command-line switch and `RebuildAndRestoreRunner` class that orchestrated the child process spawn, twenty-minute pipeline lock wait, and session restoration. The rebuild now uses the same `DrainPostProcessingAsync` flow triggered by manual POS imports, eliminating special-case logic and simplifying background coordination.

A new VendorSyncTables class in MarginMaster.Common maps each vendor to the tables its sync populates, intentionally duplicating VendorSyncRequest.GetTablesForVendor so the background service can evaluate the guard without referencing MarginMaster.CloudSync. Drift tests pin the two lists together and enforce that every table added to a vendor sync also appears in the fingerprint. The class also records that Do-it Best publishes Monday-Friday, so a Friday sync remains current through the weekend.

VendorSyncGuardTests rewritten with 19 test cases covering both sides of the 02:00 case (stale after cutoff, current before it), the Friday-before-cutoff weekend case, reset/restore scenarios, and fingerprint evidence. New VendorOnlySwitchTests pins the --vendor-only flag recognition—failure here would be silent, causing the catch-up to run a full POS import every morning instead of a seconds-long vendor sync. Full suite green: 1,727 passed.

Deleted OfferParkedRebuildAsync, CaptureSessionAndRestartAsync, LaunchRebuildAndRestoreChild, RestoreCapturedSessionAsync, RebuildAndRestoreRunner, the RebuildAndRestore command, --rebuild-and-restore and --restore-session command-line switches, and the MaxDeferrals/DeferFor deferral machinery. AppLaunchSource.Restore is deliberately kept: the server validates LAUNCHSOURCE against a fixed list and discards unknown values, so dropping the member would put the client out of step with the server contract, and it still appears in historical rows.

Background service now evaluates vendor sync decision conservatively (treats all vendors as daily-publishing) when resolving whether to launch the app, with the actual headless run re-evaluating using the real vendor type and stopping if nothing is due. Prevents the service from being overly cautious and missing legitimate runs.

When editing margin percentages or fixed retail prices, you can now position your cursor at any digit and use the up/down arrows to adjust just that digit. For example, in "41.30%", placing your cursor after the "3" and clicking the up arrow changes it to "41.40%", not "42.30%".

This improvement works across all pricing screens where you set future margins or retail prices, making it easier to make small adjustments like changing cents or tenths of a percent.

Added 18 test cases covering place-value resolution logic, including handling of currency symbols, group separators, mask literals, edge cases like empty text and out-of-bounds cursor positions, and verification that DevExpress SpinEdit correctly applies fractional increments assigned during the Spin event.

When the background service blocks an update, you'll see a new dialog that lets you stop it with one click and install the update right away.

When an update needs the background service stopped, you'll see a clear explanation and can authorize it with one click, or choose to turn the service off so it never blocks updates again.

Scheduled POS file imports will now work reliably for stores using file-based imports.

The background service has been moved to a permanent location so updates can install even when it's running, preventing the "could not stop the background service" errors that previously blocked updates.

The background service now runs from a permanent location, so updates can install even while it's running scheduled imports.

If an update can't install because something is holding the program folder, Margin Master now tries several ways to fix it automatically before asking for your help.

Stores running Epicor Compass will now properly log connection errors during scheduled imports instead of hanging.

Scheduled imports will now proceed even when vendor data is slightly out of date, rather than skipping the import entirely.

The unlock process now tries three progressively stronger methods before giving up: (1) polite stop via the Authenticated-Users grant (no UAC), (2) force-kill the service process by PID from 'sc queryex' (still no UAC), (3) hand back ServiceStopFailed so the UI can offer elevated stop or disable. Steps 1-2 run unattended in silent/headless update paths. The force-kill step clears exactly the case where the grant self-heal hasn't run yet—it needs no service rights, only rights over the process, so it succeeds when the user installed the service. Implemented in new InstallDirectoryUnlocker class with full test coverage (14 new/rewritten tests, 1,684 passing total).

Error messages about blocked updates now correctly identify what's actually preventing the update, making it easier to resolve the issue.

Moved the cleanup of main tables belonging to excluded or removed stores from the ingest to the rebuild phase for Epicor MySQL-Compass. This work now happens silently (matching prior behavior where a wildcard drop removed them unconditionally) but only after all active store tables are safely rebuilt, and includes the same store-list validation fail-safes used in the prompted cleanup path.

Previously, when an auto-update had to abort because the install directory was locked, it always reported "Could not stop the background service" regardless of the actual cause. In reality, there were two distinct reasons for failure: either another Margin Master instance (typically a headless import launched by the service) was still running, or the background service itself wouldn't stop. This led to misleading error reports—one store (Niemann Ace 13329) that had been updating successfully every day for a week reported a service stop failure when the actual issue was a data-update import in progress. The error messages now correctly reflect which subsystem caused the abort, making troubleshooting and support tickets more accurate.

Updates that couldn't install because the background service was running will now ask you to stop the service instead of just failing silently. The update will complete once the service stops.

Background price updates will no longer clear your pricing data if Margin Master is open when they run. Previously, scheduled imports could leave you with empty price tables until you manually approved a rebuild.

Scheduled updates no longer freeze when encountering problems that would normally show a popup dialog. Issues requiring attention now appear in logs and error reports instead of silently hanging.

Scheduled imports and data updates will no longer get stuck when encountering errors that would normally show a dialog, preventing overnight updates from failing silently.

Dropdown menus throughout the application will no longer go blank during background imports.

Scheduled automatic imports now work correctly for stores importing from files, even when vendor data hasn't been synced recently.

When rebuilding specific stores using Shift+click, other stores' pricing data will remain intact instead of being accidentally deleted.

Choosing "Not Now" on an update, or having an import running when an update tries to install, no longer counts as a failure that could block future automatic updates.

Margin Master now correctly distinguishes between an update that's waiting its turn (like when an import is running) and one that actually failed, so temporary delays won't block future automatic updates.

Added headless guards to StartupCheckService for license status changes, database connection validation, and schema upgrades. These operations require user confirmation or desktop windows, so headless runs now log clear error messages and throw InvalidOperationException instead of blocking forever on dialogs nobody can see. This prevents the service scheduler from pausing with no diagnostic information.

Fixed a race where AutoUpdateRestartBackgroundService was set after WaitForStatus, so a stop that timed out but completed left the sentinel unwritten and the service stayed down until reboot. Now sets wasRunning = true before calling Stop(), so the restart obligation is recorded the moment the stop is issued.

UpdateHealthState.RecordFailure is no longer called for IsDeferral outcomes (sibling process or user-declined stop). The startup post-update check skips recording when LastUnlockResult.IsDeferral is true. Silent update runs (UpdateInstaller) mark the version in UpdateBlockedByServiceLock when the service is specifically what stopped the apply, so the next interactive launch offers the fix immediately. ClearUpdateBlockedByServiceLock runs on every successful update, regardless of route, so the prompt can't outlive the problem.

Added UpdateBlockedByServiceLock (marks when a specific version is blocked by the service so the next launch offers the fix immediately), BackgroundServiceRelocated (remembers the one-time migration prompt was accepted), and clarified that AutoUpdateRestartBackgroundService is set only when a running service was stopped by the update process.

Introduced PosMainTableOwnershipPolicy to formally define which phase of an import owns the per-store main tables, with mechanical tests (PosIngestOwnsNoMainTablesTests, PosMainTableOwnershipPolicyTests) that fail if new code attempts to modify main tables or SelectionLists during the ingest phase. Almost all POS systems now correctly defer main table work to the rebuild; BisTrack and WestLake remain ingest-owned because their rebuild logic currently declines to build them.

Moved unlock orchestration from AutoUpdateService into new InstallDirectoryUnlocker class, injected as a singleton. AutoUpdateService now exposes LastUnlockResult (InstallDirectoryUnlockResult) so callers can distinguish deferrals from faults before recording failures. TryUnlockInstallDirectory returns typed outcomes instead of collapsing to bool, and logs deferrals at Warning (below ErrorReportingSink threshold) while genuine service failures log at Error. Added InstallDirectoryUnlockResult.IsUserActionable to identify the one outcome the stop-service dialog can fix. Surface-area contract pinned in MainMMViewModel.surface.approved.txt (EnsureBackgroundServiceRelocated added).

Added comprehensive test coverage to ensure both abort paths—sibling process running and service stop failure—report their own distinct error messages and cannot regress to the generic message. The tests verify that the abort decision logic remains unchanged (maintaining safety of the fleet-wide update mechanism) while the diagnostic accuracy improves.

Introduced a process-wide LaunchContext.IsHeadless flag set by every headless command (--data-update, --import-vendor, --import-pos, etc.) to identify unattended runs. Defaults to false (the safe direction: showing a dialog to an interactive user costs a click; hiding one loses information). Added HeadlessDialogHangGuardTests with code scanning to prevent raw MessageBox.Show calls in POS import code paths and verify all headless commands properly set the flag, ensuring these hangs cannot silently return.

The service executable is now signed individually (in addition to living inside the signed app folder) since it's copied to %ProgramData% and registered as an auto-start service—exactly the shape SmartScreen scrutinizes. The publish pipeline stages it into a service\ subfolder (not flat in PUBLISH_DIR) with its own secrets-injected appsettings.json. Localization satellite assemblies are stripped from both the app folder and the service subfolder. BackgroundWindowsServiceController now exposes StagedServiceFolder, InstalledServiceFolder, and StagedServiceExePath to distinguish the staging location from the run location.

The background service is now published to a service\ subfolder of the install rather than flat into the program directory, and is signed independently. The publish workflow copies secrets to both the app's appsettings.json and service\appsettings.json, and strips localization folders from both trees.

Created HeadlessDialogHangGuardTests with regex-based scanning of import partials to detect raw MessageBox.Show calls, verification that all headless command-line arguments set LaunchContext.IsHeadless, and confirmation that the safe default is interactive. The tests guard the rule that an unattended run never raises a dialog and document the specific hang signature: "Launching headless run" with no matching "exited with code" in service logs.

The uninstall hook now removes the service's binaries from %ProgramData% after stopping and deleting the service registration. Best-effort to avoid leaving orphaned files after uninstall, since Velopack only removes what it installed.

Multi-PC stores can now use File > Utilities > Installation Scripts > Enable Remote (LAN) Access to automatically set up the host computer so other workstations can share the same database.

Support can now run a single automated script on the main store computer to set up database sharing for additional PCs. The script checks everything needed for remote access and reports what's wrong, then fixes it when you run it again with -Apply.

The auto-update service now captures and logs the specific reason each update attempt is aborted, making it easier to diagnose why updates are deferred at particular stores. This addresses a real-world triage issue where Niemann Ace 13329 was reported as having service-stop failures despite successfully auto-updating every day for a week.

Database passwords are now stored encrypted for better security.

Clarified critical safety rules in the SQL Server installation documentation, including the ownership guard that prevents touching any SQL instance the application cannot prove belongs to Margin Master, instance naming behavior differences between the in-app installer and support scripts, and authentication mode (Windows-only by default). Added 30 lines of new content covering when and why a technician would need to enable remote SQL access.

Added comprehensive documentation page "Enable Remote (LAN) SQL Access" explaining how Margin Master shares databases across multiple store PCs, when the setup script is needed, what it checks, how to set up the workstation side, and troubleshooting for common connection failures (SQL error 18456, error 53, SQL Browser issues). Updated Database Setup guide to reference the script and explain that SQL Server Express defaults to Windows-authentication only. Updated Firewall and Network Requirements to document the inbound TCP/1433 and UDP/1434 rules required for multi-PC stores, scoped to Domain and Private profiles only.

When an automatic update is postponed, you'll now see a more accurate explanation of why — whether it's because a background task is running or because an import is in progress.

Fixed the Enable-SQLRemoteAccess.ps1 script to provide the correct command for applying SQL fixes. When launched from the Installation Scripts dialog, the PowerShell console starts in C:\WINDOWS\system32, not in the script folder, so the previously documented relative path (.\Enable-SQLRemoteAccess.ps1 -Apply) would fail. The script now prints the full path from $PSCommandPath at the end of each audit run, which correctly resolves regardless of working directory. Documentation updated to explain why the full path is required and to show the correct cached location.

The Enable-SQLRemoteAccess.ps1 script, launched from the Installation Scripts dialog in Support Tools, opens a PowerShell console that starts in C:\WINDOWS\system32 rather than the script's folder. Previously, instructions told users to run ".\Enable-SQLRemoteAccess.ps1 -Apply" which would fail with "is not recognized" because the relative path couldn't resolve. The script now prints the exact command with full path at the end of the audit: "& 'C:\ProgramData\RetailerSoft\MarginMaster\Scripts\Enable-SQLRemoteAccess.ps1' -Apply". Users can simply copy and paste this line to apply the fixes.

The "Upgrade SSMS" button in Database Setup now works reliably on all machines.

The Database Setup window's "Upgrade SSMS" button was downloading only the Upgrade-SSMS.ps1 shim but not the Install-SSMS.ps1 script it depends on, causing failures with "Install-SSMS.ps1 not found". Both scripts are now downloaded together, matching the behavior of the guided SQL Server Setup window which already handled this correctly.

Workstations connecting to a shared database with SQL authentication now stay connected across restarts instead of reverting to Windows authentication and requiring credentials to be re-entered.

When connecting to a shared database on another PC, your SQL login username and password now stay saved. Previously you had to re-enter them every time you opened Margin Master.

Fixed Install-OleDb12.ps1 containing two em-dash characters (U+2014) that caused "Missing closing '}'" parse errors under Windows PowerShell 5.1. Files are UTF-8 without BOM, which 5.1 mis-decodes. All ten support scripts now verified ASCII-only and parse clean under both Windows PowerShell 5.1 and PowerShell 7+.

Documentation for the Enable-SQLRemoteAccess script now explains why the full path is required and includes a note at the top of the usage section. The docs clarify that Margin Master always caches the script at the documented location regardless of whether it came from the cloud, local cache, or embedded in the application, and that the console is already elevated so no additional setup is needed.

The Installation Scripts window now includes a tool for setting up database sharing when you have multiple PCs in the store.

Added "Enable Remote (LAN) Access" to the Installation Scripts dialog with full description explaining it checks and configures host requirements for multi-PC setups, reports only by default, and requires -Apply to make changes.

Added a justified PSAvoidUsingPlainTextForPassword suppression to the -Password parameter. The password is a fixed credential compiled into the shipped client and must reach SqlConnectionStringBuilder as a plain string; using SecureString would add unnecessary complexity and break the unattended -NonInteractive execution path. The value is already masked in all output.

Created complete documentation (Upgrade-SSMS.md) clarifying that this script is a thin shim delegating to Install-SSMS.ps1, explaining when it's used (guided setup, Database Setup window, Diagnostic Tool), its parameters, exit codes, and troubleshooting. Also added the script to the documentation index with appropriate search keywords and metadata. Intentionally not added to the Installation Scripts catalog since Install-SSMS already covers that entry point.

Created comprehensive documentation explaining that Upgrade-SSMS is a thin shim that delegates to Install-SSMS, where it's used in the application, and how to troubleshoot missing sibling script errors. Documentation added to both the public docs site and the scripts folder.

Added EncryptedPasswordConverter JSON converter that encrypts SQL Server passwords at rest in DatabaseConnections.json using AES with machine-specific keys. Handles migration transparently—passwords written before this converter existed are read as plaintext and re-encrypted on the next save. Failed decryption (from a regenerated machine key or moved file) yields an empty password rather than garbage, so the app prompts for credentials instead of mysteriously failing authentication. Applied to SqlServerDatabase.Password property.

Updated last_updated timestamps on database-setup.md and firewall-network-requirements.md to reflect recent edits made during this work.

Fixed three outdated claims in sql-server-install-upgrade.md dating from February 2026: (1) SQL Server 2025 Express is no longer preview and is now the default with 2022 as fallback, not a user choice, (2) documented the ownership guard rule that prevents the installer from touching any SQL instance it cannot prove belongs to Margin Master, and (3) clarified that new instances use Windows Authentication only with no sa account, pointing to the remote access documentation for multi-PC scenarios. Also documented the instance naming behavior (defaults to SQLEXPRESS, uses dedicated name only when occupied) and how it differs from the Install-SQLExpress.ps1 script (which always defaults to MARGINMASTER).

Added the new Upgrade-SSMS documentation to the searchable index with appropriate keywords including "Install-SSMS not found", "shim", "ssms 18", "ssms 19", "ssms 20", and "ssms 22" to help support staff find troubleshooting guidance.

Added comprehensive documentation including support script guide (enable-sql-remote-access.md), updates to database-setup.md and firewall-network-requirements.md covering the shared MarginMaster login and host configuration requirements, troubleshooting guide for common connection failures (error 18456, 53), and search metadata for "second PC", "workstation", "login failed", etc.

Added DatabaseConnectionAuthenticationTests with eight test cases covering SQL authentication detail extraction from connection strings, Windows authentication clearing stored credentials, handling empty/unparseable connection strings, connection string rebuilding from stored records, and encrypted password JSON serialization round-trips. Pins the regression where authentication mode was hard-coded to Windows-only.

Added DatabaseConnectionAuthenticationTests with 188 lines covering SQL authentication persistence, Windows authentication credential clearing, empty/unparseable connection string tolerance, connection string rebuilding, and encrypted password round-tripping. Pins the regression where authentication details were discarded on save.

Epicor Eagle imports now properly close their connections, preventing the "server disconnected" error from appearing after multiple retries.

When an Epicor import fails, the error message now tells you what actually went wrong (network issue, server problem, or bad credentials) instead of always saying to check the server address.

The Data Aging View now clearly shows vendor data ages in "business days" while POS data ages in "days"—both are correct, just counting different ways.

If vendor sync runs but doesn't actually update catalog tables, the Data Aging View now shows a red warning telling you the real merge date and to run Get Vendor Data again.

Dollar amounts and quantities in strategy filters now display with proper formatting—dollar signs for costs, commas for large numbers, and percentages for margins.

All number entry fields now display with proper formatting: dollar signs for prices, percent symbols for margins, and decimal formatting for quantities. This makes it clearer what type of value you're entering.

When entering price ranges or manual amounts, empty fields now start at "$0.00" instead of blank, and clicking in a field selects the number so you can type right over it.

If you uncheck the Manual option and then check it again, your previously entered amount will still be there instead of being erased.

Unchecking "Manual" in price comparisons now correctly hides the amount entry box. Your typed amount is saved if you check Manual again.

The Manual amount entry box now appears only when the Manual option is checked and disappears when you uncheck it. Your previously entered amount is remembered if you check Manual again.

Margin filters now show percentages matching the grid columns (e.g., "35.00%"). Note: Old margin rules may display incorrectly (3,000% instead of 30%) if they were saved with wrong values—these rules weren't working correctly before, but the issue is now visible.

When setting up rules that compare Current Margin or other percentage fields, the value entry box now shows percentages (like "10.00 %") instead of plain numbers, matching what you see in the grid.

When you select a comparison operator like "Greater Than," the value box now starts with 0 instead of being blank, and the number is pre-selected so you can just start typing your amount.

Percentage-based pricing rules now save and filter correctly. Previously, a rule like "Current Margin < 10%" wouldn't match any products because it was actually comparing against 10.0 instead of 0.10.

The Manual amount entry box now appears directly under the "Manual" option instead of at the bottom of the panel, making it clearer which field you're filling in.

The Manual amount entry box now appears on its own line below the Manual checkbox, making it easier to see and use without text getting cut off.

The Future Price panel's Margin % and Fixed Retail fields now have consistent styling with a cream background and gold border.

Introduced SelectionValueEntryPolicy as a pure, testable decision function that determines which value editor to show based on row state. Added 15 unit tests pinning the behavior, including the specific "Manual unchecked shows nothing" case that was the original bug. Separated presentation logic from decision logic to enable reliable testing of the UI state machine.

Fixed a critical defect where the DataUpdate job could not record its last-run timestamp due to an incorrect mapping, causing the background service to re-download vendor catalogs every five minutes indefinitely until manually stopped. The job-to-setting mapping is now exhaustive and logs an error if a job type has no marker rather than silently using another job's key.

The background service was repeatedly relaunching the DataUpdate job every five minutes because it was writing the last-run timestamp to a retired setting key. The job could not record that it had run, so the schedule stayed permanently due. Added exhaustive mapping to ensure every job type writes to its own last-run marker, with loud failures if a new job is added without one.

When you agree to a data rebuild, the system now waits for any background work to finish before applying it, instead of asking you again.

The background service now checks whether a rebuild from the previous run is still awaiting user consent before ingesting data again. Previously, if the user hadn't responded to the first prompt, the service would re-download the data, stack a second prompt, and race any rebuild the user eventually agreed to.

You will no longer see multiple rebuild prompts stacking up while waiting to respond to the first one.

After agreeing to a data update, the rebuild will now wait for any background jobs to finish rather than asking you to restart again.

Your saved filters and selections are now properly restored after a data rebuild completes successfully.

Your table filters, selections, and grid view are now properly restored after agreeing to a data update and restart.

When your session is restored after a data update, the pricing grid now automatically reloads with your filters applied instead of appearing empty.

Added contract tests that walk the BackgroundJobType enum and verify each job has its own unique last-run setting key. Prevents future jobs from being added without proper scheduling markers, which would cause infinite launch loops.

Interactive session presence tests now adapt to whether Margin Master is already running on the test machine instead of asserting "no instance present" unconditionally, which previously caused test failures on machines where someone had the app open during testing.

The migration explicitly sets the Execute Strategy step to false, ensuring that unattended repricing is never enabled during migration since the retired schedule model did not imply consent to automatic price updates. Migration failures now retry on next startup rather than marking themselves complete, preventing stores from being left permanently unmigrated.

Fixed a critical path where stores updated silently by the background service never migrated their schedules. The service relaunches through --post-update-start-service which exits before the database opens, preventing app-side migration from running. The service now migrates schedules on its own startup, ensuring stores that never open the app can still convert to the new schedule format and continue importing overnight.

The migration that converts legacy Vendor and POS schedules to the new Data Update job format now executes from the Windows service itself, not just the app. This fixes a critical gap where stores updated silently by the service (without the app ever launching) would never migrate, causing them to silently stop importing overnight data. The service-side migration runs before the first schedule evaluation, ensuring stores remain operational.

The automatic app update check was reshaped from mode/interval to days-and-time but was not being migrated. This would have caused stores to never auto-update again after taking this release, as the service would find no days selected and treat the job as unrunnable. All three background schedules (vendor sync, POS import, and app updates) are now properly converted, with all seven days selected to preserve the previous daily behavior.

The migration now also converts the app update check schedule from the retired interval-based format to the new days-and-time format. Without this conversion, stores would stop checking for updates entirely, preventing them from receiving future fixes. The migration defaults to checking all seven days to preserve the existing daily check behavior.

Created a unified BackgroundScheduleMigrator class used by both the desktop app and Windows service, ensuring they can never disagree about a store's schedule configuration. The migrator accepts get/set delegates so it can work against either the app's settings service or the service's SQL reader without creating dependencies between them.

The app and background service now share a single BackgroundScheduleMigrator implementation rather than maintaining separate copies. This prevents the two components from disagreeing about a store's schedule configuration, which would be worse than either being wrong independently. The shared migrator is tested with 191 test cases covering all migration scenarios.

Added 191 lines of tests covering all migration scenarios including idempotency, edge cases with missing settings, the critical safety property that migration never enables unattended repricing, and verification that both the app and service call the shared migrator. Also added reachability tests to ensure the migration runs on every possible update path.

Open Strategy > Get Premade Strategies to see ready-made pricing strategies for your vendor. Click "Download / Update" to install one, then open it in the Strategy Manager. To customize it, use the "Copy Current Strategy" button to create an editable copy.

Instead of building pricing strategies from scratch, you can now download starter strategies built by RetailerSoft for your vendor. Open Strategy > Get Premade Strategies, select a strategy, and click Download. The downloaded strategy is read-only — open it in the Strategy Manager and use "Copy Current Strategy" to make an editable copy you can customize.

Open Strategy > Compare Strategies to capture snapshots of your pricing results and compare them side-by-side. The report shows how much profit each strategy gains and which one wins.

The Strategy menu now has "Get Premade Strategies" — a library of ready-to-use pricing rules you can install with one click. Installed strategies are read-only templates; use "Copy Current Strategy" to make an editable version.

Open the Strategy menu and select "Compare Strategies" to capture your current pricing results with a custom label (e.g., "2023 Current Rules"), then run a new pricing strategy and capture it again (e.g., "2024 Test Strategy"). Select both snapshots, choose whether to view results Overall, By Store, or By Department, and click "Build Comparison" to see which strategy makes more money and by how much per year.

Look for "Strategy Utilities…" in the Strategy menu to access all strategy tools in one place.

A new "Strategy Utilities" option in the Strategy menu provides one-click access to all pricing strategy tools in a single dialog.

Price sensitivity analysis is now available for both Ace Hardware and Do it Best stores, showing which departments are most "blind" (eligible for price increases) versus most "sensitive" (requiring careful pricing).

On the Manage Custom Groups screen, click the hamburger menu and choose "Copy Group from Another Strategy..." Pick a strategy from the left list, then pick the group to copy from the right list. The system will suggest a name for the copied group. Click "Copy Group" and the group will be added to your current strategy with all its SKUs and settings intact.

On the Manage Custom Groups screen, click the hamburger menu and choose "Copy Group from Another Strategy..." to copy a group from a different pricing strategy into the current one. The original group is not changed.

When SKU exceptions are missing a price level, the hamburger menu now shows "Resolve Unassigned" with options to delete them all, inactivate them all, or assign a price level to all of them at once. This fixes the common problem where imported strategies contain hundreds of exceptions that can't price anything.

If you have active SKU exceptions with no price level (which the strategy pre-flight warns about), you can now fix them all at once using the "Resolve Unassigned" menu instead of editing each one individually.

Open File > Utilities > Import Competitor Prices, click Download Template to get a correctly formatted spreadsheet, fill in your SKU and competitor price columns, then browse to your file and click Import. The prices appear in Competitor 1 through Competitor 5 columns.

Open File > Utilities > Import Competitor Prices, select your spreadsheet, review what was found, and click Import. Your competitor prices will load into the Competitor 1–5 fields where you can use them for pricing analysis and strategies.

When importing competitor prices, you can now choose "Add" or "Replace" for each column. Use Replace when your POS already fills the field and you want only your own prices there, or when reloading a shop report and old prices should not remain. The window shows how many items already have values so you can make an informed choice.

Check or uncheck "Show this summary after each strategy run" to control whether this report appears. You can also find this setting in Options > Miscellaneous. The strategy still runs the same way and logs everything normally — only the summary report is hidden.

When saving SKU exceptions that price below cost, you'll see a warning listing which items and why (e.g., "1005412 — its -25% margin prices below cost"). You can review and choose "Save anyway" if it's intentional.

When saving a SKU exception that prices below cost, you'll see a warning listing which items and why (e.g., "1005412 — its -25% margin prices below cost"). You can review and choose to save anyway if it's intentional.

Strategies you download from the premade catalog are read-only and show a banner explaining this. Click "Copy Current Strategy" to make an editable version you can customize.

Downloaded strategies show a banner "Shared strategy vN — read-only" in the Strategy Manager. You can execute, activate, export, and back them up, but to make changes you must use "Copy Current Strategy" first. When a newer version is available, re-download it from the catalog — since the original cannot be edited, no local changes can be lost.

Support staff can publish local pricing strategies to the shared catalog for all stores to use.

Your captured pricing snapshots are saved locally on your computer and remain available even after syncing with the cloud, so you can compare strategies weeks or months apart.

Every time you run a strategy, the system automatically saves a snapshot of what changed. You can later compare these snapshots to see how different strategy runs affected your pricing. Only the most recent automatic snapshot for each strategy is kept.

Every time you run a strategy, Margin Master now saves a snapshot of the price changes in the background. You can turn this off in the Compare Strategies dialog if you prefer to capture snapshots manually.

On the Manage Custom Groups screen, click the hamburger menu and choose "Find Duplicate SKUs..." to see any SKUs that appear in more than one group. Click the X next to a group name to remove that SKU from that group immediately. This helps prevent pricing conflicts where the same item is assigned to multiple groups.

Click the hamburger menu and choose "Find Duplicate SKUs..." to see which items appear in more than one custom group. Click the X next to a group name to remove that item from that group.

When custom groups are missing a price level, the hamburger menu now shows "Resolve Unassigned" with options to delete them all, inactivate them all, or assign a price level to all of them at once.

If you have active custom groups with no price level, you can now delete them, inactivate them, or assign a price level to all of them at once using the new "Resolve Unassigned" menu.

When importing competitor prices, you can now choose "Replace all existing values" to clear out prices that came from your POS system, so filters like "Competitor 1 greater than 0" return only the items in your spreadsheet.

When you open or run a pricing strategy, Margin Master will now automatically show any columns that strategy needs, so you can see and edit all the price levels the strategy uses.

If you have a custom group named something like "25%Margin" that stopped pricing, the app will now offer to restore the 25% margin setting when you open or close the custom groups screen.

When saving custom groups that price below cost, you'll see a warning listing affected groups and the reason (e.g., "Clearance Items — it prices from cost and then subtracts").

When saving a custom group that prices below cost, you'll see a warning listing which groups and why (e.g., "Clearance Items — it prices from cost and then subtracts"). You can review and save anyway if it's intentional.

Support users can share a pricing strategy with all stores by opening it in the Strategy Manager and selecting "Update or Create Shared Strategy" from the menu.

(Support machines only) You can publish a local strategy to the shared catalog using the "Update or Create Shared Strategy" menu item in the Strategy Manager. Margin Master will validate the strategy and warn you about anything that might not work on all stores before publishing.

View your comparison across the entire organization, broken down by individual store, or broken down by department — the dollars always add up to the same overall total.

The Compare Strategies screen now shows whether each saved strategy result is "Current" or "Not Current" based on whether your data or the strategy itself has changed since it was last run.

When analyzing strategies, you can now check "Combine stores" to see departments and classes rolled up across all your stores—useful when you price all stores the same and don't need to see each store separately.

You can now check "Combine stores" to group pricing by department and class across all your stores at once, since most stores price everything the same way anyway.

When assigning a price level to multiple exceptions or groups at once, you'll see a picker showing only price levels that work without additional settings.

After importing, Margin Master asks if you want to display the competitor columns you just loaded so you can see the prices right away.

Before running a strategy, you'll now see a warning if any custom groups or SKU exceptions are incomplete and won't price anything, giving you a chance to fix them before the run.

Click "Export to Excel" to save the comparison table for sharing with management or further analysis in Excel.

If you select strategies with outdated results, the system offers to automatically rerun them before showing the comparison, ensuring you're always comparing current numbers.

The import understands prices like "$1,234.567" (rounds to $1,234.57) and skips blank cells instead of zeroing them out, so your existing prices stay safe.

Every import creates a log file showing exactly what happened—which prices were loaded, which cells were skipped, and which SKUs weren't found in your database. Click "Open Log" to review it.

Open the Strategy menu and select "Compare Strategies" to capture your current pricing results with a custom label (e.g., "2023 Current Rules"), then run a new pricing strategy and capture it again (e.g., "2024 Test Strategy"). Select both snapshots, choose whether to view results Overall, By Store, or By Department, and click "Build Comparison" to see which strategy makes more money and by how much per year.

Your captured pricing snapshots are saved locally on your computer and remain available even after syncing with the cloud, so you can compare strategies weeks or months apart.

View your comparison across the entire organization, broken down by individual store, or broken down by department — the dollars always add up to the same overall total. Click "Export to Excel" to save the comparison table for sharing with management.

Sensitivity scores now range from 0 (least sensitive) to 100 (most sensitive) within each group, making it much easier to spot which areas are most affected by price changes.

Each row's sensitivity score now shows how it ranks against its peers—100 means most price-sensitive in its group, 0 means least sensitive—making it easier to spot which departments or classes need the most careful pricing.

Sensitivity scores now show the real number instead of exaggerating small differences between stores. The color helps you spot which items are more price-sensitive (red) versus less sensitive (green), but only when there's enough data to be confident.

At Ace stores, "MAP Price" and "IMAP Price" are always available when setting future prices, so you can correct critical pricing violations with one click.

When you click "Just Run" in Ace Critical Pricing, Margin Master now automatically fixes the pricing violations and shows you what was changed, instead of just listing the problems. You'll see a breakdown of how many items were corrected in each category (below-cost, below-MAP, below-IMAP).

When you click "Just Run" in the Ace Critical Pricing tool, Margin Master now immediately fixes pricing violations and sets future prices for you. You'll see a summary of how many items were corrected in each category (below-cost, below-MAP, below-IMAP), and the grid will display the items with their new future prices ready to export to your POS.

When the system suggests margin percentages for your pricing groups, it now shows the step number so you can easily find which group it's referring to.

When a RockSolid price export fails, you'll now see exactly what's wrong (like "RockSolid.RS is marked read-only" or "another program has the file locked") instead of a list of possibilities to check.

Your saved pricing strategies will continue working with all their original settings even after you customize which fields are visible in your workspace.

Added a new CreateFuturePriceSetToLevel method to PriceLevelListService that builds a single set-to level item outside the normal offered-list filter, enabling the restoration of price levels that exist in saved rules but aren't currently surfaced by the active view.

When comparing strategies, you now select them by name, and the system tells you if their results are out of date. Out-of-date strategies are automatically rerun before the comparison shows, so you always see accurate results.

You can now compare up to three pricing strategies side-by-side instead of just two, making it easier to evaluate multiple options at once.

Each strategy picker row now tracks its own IsEnabled state independently, allowing the UI to dynamically enable or disable individual checkboxes based on the current selection count. This provides clear visual feedback about which strategies can be selected at any given moment.

Added an IsEnabled property to strategy picker rows that dynamically updates as selections change. Unselected strategies become visually disabled (greyed out) when the three-selection cap is reached, while previously selected strategies remain enabled and can be deselected.

Column headers now show your actual strategy names instead of "Baseline" and "Candidate."

After comparing strategies, you'll be asked whether you want to recalculate your original strategy's prices (which can take a while), clear the prices, or leave them alone—no more waiting for automatic recalculations you might not want.

After comparing strategies, you now choose whether to reapply your original strategy (which reruns it completely), clear the Future Prices, or keep them as-is—no more waiting for automatic reruns you might not need.

Column headers are now simpler and easier to read, showing just the metric type since the strategy name appears in the group header above.

Improved the error log message when Future Price panel initialization fails at startup to clearly indicate that the panel will be unavailable for the session and that no strategy steps can execute. This helps support staff quickly identify the root cause when users report strategy execution failures.

When reviewing pricing rules, you'll now see a clear message telling you "it is a Set-to-SKU rule with no SKU entered" instead of a generic error, making it easier to fix the problem.

You'll now see a warning message if a pricing strategy tries to use a min/max model that doesn't exist in your database.

Since the anchor SKU lookup is group-level and deterministic (every batch in the group uses the same missing anchor), the system now short-circuits execution after detecting the first failure instead of attempting to process each remaining batch with identical failures. This reduces unnecessary processing and log noise.

Hiding the summary doesn't change how the strategy runs or what information is saved — it only hides the report window.

When SKU exception loading fails, the error log now includes the strategy name, SKU (if filtering to a specific SKU), and how many exceptions had successfully loaded before the failure. This helps distinguish between "no exceptions exist" and "the load failed partway through," since both previously resulted in an empty grid with no visible error.

Enhanced error logging to report which pricing strategy was being loaded, which SKU (if filtering to one), and how many exceptions had successfully loaded before the failure. This helps distinguish between "no exceptions exist" and "the load crashed partway through."

The "Set Future Price to" list now updates automatically when you change column views or selection boxes — extended price levels appear only when their fields are visible.

The auto-capture checkbox in the Compare Strategies dialog now saves its state immediately when toggled, rather than waiting for the dialog to close. Since the dialog has no OK/Cancel buttons, this prevents the setting from being lost when the user closes the window.

You can now compare up to three pricing strategies side by side instead of just two.

Hovering over a sensitivity score shows both the relative ranking and the detailed breakdown of price sensitivity metrics.

The Future Price panel now matches the behavior of margin and fixed retail rules by not emitting action tokens when the SKU field is left blank, preventing the creation of malformed pricing rules at the point of entry.

If a pricing step references a min/max strategy that isn't set up in your database, you'll now see a clear warning instead of having the setting silently removed.

After applying price changes to Ace Critical Pricing items, the list stays on screen with the new future prices shown, and the Summary panel updates to reflect your changes.

The Critical Retail Pricing documentation now describes "Just Run" as "Instant Correction" rather than "Instant Analysis," clarifying that it applies price changes immediately instead of just displaying a list for manual review.

The import completion message now clearly tells you how many SKUs from your file were successfully applied to your pricing data.

The log file now includes which columns were Replaced vs. Added, how many values were erased before the file was applied (per table and per column), and clarifies that SKUs "not in any main table" (rather than "not in Store") were skipped. The completion message and log both remind users that competitor prices are cleared by the next main-table rebuild (POS import, cloud sync, or manual rebuild) and must be re-imported afterwards.

Introduced MainTableSelectionPolicy.RoutingListIsEmpty and RemoveEmptyRoutingKeys methods to consistently detect and remove empty store routing filters before they can cause discovery failures. GetFiltersDictionary now omits empty StoreGroup values rather than publishing them, matching the existing behavior for StoreNumber. The system logs a warning when empty routing keys are removed, helping identify misconfigured store grouping settings.

Added safety checks when looking up price levels by index position. The system now validates that indexes are within valid ranges before using them, and falls back to the recorded price level enum when available. Competitor price levels (Comp1-5) are now resolved by identity rather than list position, preventing the same type of mismatch that caused the main defect.

The below-cost warning only appears when the system is certain the price will be below cost, so you won't see unnecessary alerts on normal pricing rules.

Introduces ISittingMarginQueryService, which runs the shared sitting-margin bucket query against every resolved main table and returns the raw per-grain rows (Store/VendorOwned/Velocity/Dept/Class with additive CP/FP/COGS dollars). This is the sitting-margin calculation as a first-class product — no Profit Analyzer ViewModel spin-up required — so the Strategy Comparison dialog can capture results independently of the Profit Analyzer screen.

The message when capturing a new snapshot now correctly states it captures all store pricing data, not just selected items.

When you compare strategies that need updating, the app runs them one by one automatically, shows progress for each, then displays the comparison when all are finished.

Sensitivity scores based on limited data now appear without color highlighting, so you know they're less reliable.

The "Resolve Unassigned" menu appears automatically when SKU exceptions or custom groups are missing price levels, and shows the exact count of affected items.

The strategy pre-flight warning now tells you about the "Resolve Unassigned" menu when it finds pricing rules that won't work.

The "Found X critical pricing items" message box now opens only after the loading splash screen is fully closed, following the application's splash-before-modal rule. Previously the message could appear while the splash was still visible.

The A/B comparison aggregates detail rows to the selected grain using the same SittingMarginMath roll-up, ensuring the grand total is dollar-weighted (not an average of per-grain percentages) and reconciles exactly with the per-store and per-department rows. Candidate-vs-baseline dollars is the incremental profit the new strategy makes over the old one (candidate annual $ − baseline annual $), and when a grain is absent from the baseline snapshot (e.g., a new department), the baseline dollars fall back to zero and the sitting anchor comes from the candidate's current price.

Help documentation now includes a "Replace or Add" section explaining when to use each mode, notes that Epicor and Paladin POS systems pre-fill Comp1–Comp5, clarifies that prices are cleared by main-table rebuilds (not just POS imports), corrects the technical detail that main tables are what matters (not [Store]), and adds staged multi-file import instructions (first file Replace, subsequent files Add).

Shared strategies are identified by a stable template key derived from the strategy name (lowercase, spaces/punctuation to hyphens, deduplicated hyphens, trimmed). This key is used for upsert operations during publishing and for matching installed strategies to catalog updates, allowing strategies to be renamed in the catalog without breaking the link to already-installed copies.

Adds comprehensive user documentation at docs/marginmaster/pricing/import-competitor-prices.md covering file format, recognized column names, value parsing rules, the import workflow, how to use competitor prices in strategies and variance columns, log location and contents, and common questions including the POS import durability caveat and SKU matching behavior. Indexed with 18 search keywords including "shop report", "market price", and "load competitor prices".

The fire-and-forget snapshot capture after each strategy run now stamps the snapshot with the current freshness marker via the new optional dataVersion parameter. The capture method is also exposed as an awaited Task<int> for the compare orchestrator to call synchronously between back-to-back runs, preventing the race where fire-and-forget capture overlapped with the next run's FuturePrice reset.

If you previously set up a custom group with a margin percentage and found it wasn't pricing anything, you'll need to open it, re-enter the margin %, and save it again. The app will now keep your settings.

If you saw a padlock icon showing an exception exists but couldn't see it in the SKU Detail tab, those exceptions will now appear correctly.

If a SKU had a pricing exception but the Sku Level Exceptions tab showed nothing, it will now display correctly.

Pricing rules with negative margins (like -25% to price below cost) now save and run correctly instead of showing a "will be skipped" error.

If you set a negative margin percentage to price below cost, the exception will now apply correctly when your pricing strategy runs.

The application will no longer crash when checking for old Margin Master versions during startup.

When you save custom groups, any warnings about missing price levels or below-cost pricing now show both the step number and group name (like "step 6 - PLUMBING L2"), making it easier to find the right row when you have groups with the same name in different strategies.

When you save pricing groups and see a warning, it will now show "step 2 - PLUMBING L2" instead of just "PLUMBING L2", making it easy to find the exact row that needs fixing.

If a price export to RockSolid fails, your existing queued prices in the POS will no longer be lost.

Added back the System.Text reference required by ProfitAnalyzerViewModel, which was causing a compilation failure after the strategy comparison code was recovered.

If you saved a strategy step to update zone pricing or a custom field, then later hid that field from your view, the step will now still work correctly instead of silently skipping all items.

When you load a pricing rule that uses a price level not currently shown in your view (like a zone price when zone columns are hidden), the rule will now work correctly instead of silently failing. Your pricing strategies will apply as configured even when you switch between different column views.

When opening a saved pricing rule, zone pricing levels and other special levels now appear in the right spot in the dropdown menu instead of at the bottom of the list.

When you open a saved future price rule, any pricing levels that were previously selected but aren't normally shown will now appear in their correct position in the dropdown list instead of at the very bottom.

When you check or uncheck a pricing strategy in the comparison picker, the selection now registers right away. Previously, you had to click somewhere else before the selection would take effect and enable the Compare button.

When selecting strategies to compare, the checkboxes now respond instantly when clicked. The Compare button and the limit of 3 selections will update right away instead of after clicking elsewhere.

Fixed a rendering issue where the Strategy Comparison screen's column headers displayed internal system text ("System.Windows.Controls.StackPanel") instead of the intended two-row format with strategy name and metric label. The fix restructures how headers are defined using HeaderTemplate instead of direct Header content, allowing the TreeListControl to properly display strategy names bound from the view model. All nine comparison columns (Baseline and Candidate strategy metrics for projected percentage, delta points, and annual dollars) now show the correct formatted headers.

The comparison tree no longer feels sluggish when scrolling through pricing strategies with many low-coverage items.

The Strategy Comparison screen will feel more responsive and smoother, especially when scrolling through large lists of items.

If a pricing strategy fails to run and shows a message about the Future Price panel not being initialized, restart Margin Master. If the problem continues, contact support—there may be an issue loading your store's rounding schemes or cost break data.

If you see an error about the Future Price panel not being initialized when running a pricing strategy, restart Margin Master. If the error continues, contact support as there may be an issue loading your store's pricing configuration data.

You'll no longer see warnings about custom group rules that wouldn't actually run anyway.

The warning dialog before running a strategy will no longer show custom groups that won't actually run.

If you accidentally left the SKU field blank in a "Set to SKU" pricing rule, that step will now be skipped instead of stopping your entire pricing strategy. You'll see a warning in the pre-flight check so you can fill in the missing SKU before running the strategy.

If you previously created a pricing rule with "Set to SKU" selected but forgot to enter a SKU number, the entire pricing strategy would stop working. Now that rule will simply be skipped, and your strategy will continue processing remaining rules normally.

The Active checkbox now responds immediately when clicked, allowing you to quickly enable or disable SKU exceptions and custom groups without extra steps.

In SKU Exceptions, you can now click once on the Active checkbox to enable or disable an exception instead of having to navigate to the cell first.

When you run a pricing strategy with min/max limits across multiple store groups, those limits now correctly apply to all groups instead of only the first one.

When running pricing strategies on store groups with multiple tables, min/max rules (like MAP enforcement) now correctly apply to all tables instead of only the first one.

If you run a custom pricing group that's set to match another item's price, but that item has been deleted from your POS system, Margin Master will now show a clear "SKIPPED" warning explaining what happened instead of appearing to succeed with no changes.

When reviewing Ace Critical Pricing items, you can now always choose "MAP Price" or "IMAP Price" from the Future Price panel's dropdown to quickly correct pricing violations.

When you deliberately run Execute Strategy again within 2 minutes of finishing the previous run, the system will no longer ask you to confirm — it knows you meant to do it. The confirmation only appears for unexpected automatic runs.

When editing a single SKU exception, your changes will now save properly. If a save fails, you'll see which SKUs had problems and can try again — changes won't be silently lost.

When you set a price level for a SKU exception that previously showed "U" (unpriced), the Type column will now immediately show the correct letter (R/M/D/C/S) representing the assigned price level, without needing to close and reopen the dialog.

If you use Epicor or Compass POS, competitor price imports will now show the correct "SKUs applied" count instead of falsely reporting that your items weren't found.

If you accidentally turned on Store Grouping without setting up any groups, automatic pricing will now work correctly instead of silently skipping all items.

Fixed MM-1397 where a rule set to "55% Margin" could be saved as "Store Cost" and reprice items incorrectly. Store 5088 had a rule that should have set 55% margin but instead repriced 395 items to cost on every strategy run. The root cause was that the system saved which position a price level was in a list, not which level was actually selected. When zone price levels were restored into one list but not another, the positions fell out of sync and the wrong level was serialized. The system now records the actual price level selected, making the save process immune to list position changes.

Custom groups set to calculate margin from Average Cost or Replacement Cost will now stay on that cost basis when you reopen and save them.

The Active filter now correctly shows only active exceptions instead of showing everything.

Filtering SKU exceptions by Active or Inactive status now shows the correct records without changing their active state.

The old version uninstall prompt can now be clicked and responded to instead of being stuck behind the startup screen.

When you refresh the list of saved pricing snapshots, your currently selected baseline and candidate snapshots will stay selected instead of resetting.

Pre-flight warnings for SKU exceptions now accurately reflect which rules will actually run.

The warning dialog before running a strategy will no longer show SKU exceptions that won't actually run.

In Custom Groups, you can now click once on the Active checkbox to activate or deactivate a group item instead of having to navigate to the cell first.

Min/max strategies now work correctly even when comparison or zone price columns are empty for some items.

Clicking "Apply" in the Future Price panel now updates only the critical pricing items shown in the grid, not every item in your store. The list stays on screen after Apply so you can see the corrected prices immediately.

When viewing Ace Critical Pricing results, clicking Apply in the Future Price panel now changes only the items shown in the list, not every item in your database.

If any pricing rule can't be applied safely (for example, if MAP data is missing), that correction is skipped and reported in the results message, preventing accidental store-wide price changes.

When you remove stores from a custom group's conditions, those changes now save correctly instead of being lost.

In the Resolve Unassigned workflow, SKUs you've just fixed will now disappear from the list immediately after you save, making it easier to track your progress through unassigned items.

The import now correctly tells you how many prices were applied. Previously it could report "SKUs not found" even when the prices had successfully loaded into your pricing grid.

The pricing grid and reports now find your inventory correctly when store filters aren't set, rather than showing empty results.

Products with apostrophes or quotes in their codes (like 1/2" X 6') now export correctly to RockSolid.

Changed SittingMarginQueryService and StrategyComparisonService from singleton to transient registration to match the lifetime of ISelectionService, preventing potential dependency injection errors.

OneClick statistics now show the correct price sensitivity labels and categories for your vendor (Ace Hardware or Do it Best), with all sensitivity codes properly displayed.

When editing custom groups, switching between groups no longer asks if you want to save, and your changes are kept until you click Save or close the window.

You can now edit multiple custom groups without saving after each one—your changes stay in place until you click Save or close the window.

Loading and re-saving a strategy in a database that's missing the referenced min/max model no longer permanently deletes the step's min/max configuration. The InstructionSet and StrategyFormulaService now keep the ACTIONMINMAX reference even when the model lookup fails, preventing accidental data loss.

The Summary panel at the bottom now shows how many critical pricing items have been corrected (have a future price set).

If you select a pricing method but leave the value blank, the Save button will now activate so you can be prompted to complete or discard your change.

Added null safety when processing the RuleText field during legacy exception migration. Exceptions with missing rule text no longer crash the migration process.

Computers configured with European number formats (comma as decimal separator) now export prices correctly to RockSolid.

All stores now see the same consistent behavior: price levels appear in the dropdown only when the matching field is visible in your current layout.

The min/max case expression now NULL-guards the level column (Comp5, zones, etc.) so that NULL values are read as 0 (no clamp) instead of propagating NULL into FuturePrice. Previously, a NULL Comp or zone level would cause the entire CASE statement to evaluate as UNKNOWN and write NULL into the FuturePrice column.

The Active column in the database is now updated alongside rule text during saves. Previously only the rule text was written, causing the Active flag to diverge and break pre-flight filtering queries.

Import and export built byte-identical connection strings, so ADO.NET handed the export the import's pooled ACE session. Because an ACE session's open mode is fixed when first opened, a read-only import session made the export fail with no filesystem evidence. The connection string now includes `OLE DB Services=-4` to disable pooling, ensuring each operation gets its own session with the correct access mode.

SKU exceptions with specific rounding schemes will now keep those schemes when you reopen them.

If you cancel a strategy run before it starts, the app will no longer think you just ran it and ask if you want to run it again immediately.

The FuturePricePanel now exposes RefreshPriceLevelList(), called by MainMMViewModel when the active column view or selection box view name changes (OnActiveColumnViewName_Changed / OnActiveSelectionBoxViewName_Changed event handlers). The refresh captures the selected enum, rebuilds the ItemsSource from the service, re-applies the specific-value captions (Cost Break, Margin, Fixed Retail, SKU), and restores the selection to avoid a transient TwoWay binding swap. MainMMViewModel's own PriceLevelList (indexed against the panel's selection in CanTakeSnapshot) rebuilds in lockstep. The Edit Columns and Edit Selection Boxes dialog closes also trigger the refresh (MainMMViewModel.Dialogs3.cs) so membership changes take effect immediately.

If you configured a custom group or SKU exception using a price level that isn't currently visible on this computer, it will now keep that price level setting instead of losing it when you save.

Added three new API endpoints under api/v2/SharedStrategy: GET (catalog list filtered by vendor type), GET /{templateKey} (full definition including steps and bundled rounding schemes), and POST (publish with machine-hash authorization). Catalog items include metadata only; full definitions are fetched separately to minimize bandwidth. The server stores definitions as opaque JSON, allowing step RuleText content to evolve without server changes.

If a cell is blank or contains text like "N/A", that price is skipped and the existing value is kept — nothing is ever accidentally zeroed. Every import writes a log showing what was recognized, what was ignored, and any rows that couldn't be imported.

`ExportService` now binds to `DataViewBase` instead of `TableView`, enabling Excel export from both grid and tree list controls. This allows users to export the new hierarchical comparison results while preserving the existing flat-grid export functionality elsewhere in the application.

Competitor prices are stored with your POS data and will be replaced the next time you import POS data — keep your spreadsheet and re-import after each POS import.

Click "Download Template" to get a pre-formatted Excel file you can fill in with your competitor prices—the headers and format are already correct.

The Strategy Execution Summary now has a cleaner look with just one title instead of two.

Extended price levels like Level3, Comp prices, or zone pricing now appear in the "Set Future Price to" dropdown only when you've added those fields to your column layout or selection boxes. Basic options like Current Price, Future Price, and Store Cost are always available.

The buttons to browse premade strategies and compare strategy results are now at the top of the Strategy Manager screen instead of in the Strategy menu.

To access premade strategies or compare results, open Strategy Manager (Ctrl+S)—the buttons are now in the toolbar at the top of that window.

When selecting pricing strategies to compare, you can now pick up to three. After checking three strategies, any unchecked boxes will grey out. Simply uncheck one of your selections to enable the others again.

When you select three pricing strategies to compare, the checkboxes for other strategies will grey out so you know you've reached the limit.

The comparison grid now uses "Current" instead of "Sitting" to describe your store's existing prices, and shows how much money each strategy would gain or lose "vs Current" prices.

When comparing pricing strategies, columns now clearly show they're comparing against your current prices, making it easier to understand potential margin impact.

Comparison results now appear as a tree you can expand and collapse. Start with stores, then click to see departments within each store, then classes within each department.

Results now show as a tree you can expand: stores at the top level, departments inside stores, and classes inside departments. Collapsed stores show the store total; expand to see the breakdown.

Before rerunning strategies for comparison, the confirmation message now tells you if your active strategy will need to be restored afterward, so you won't be surprised by an extra step.

Before running a comparison, you'll now see a clear explanation if your active strategy needs to be rerun afterward to put your prices back the way they were.

Strategy comparison results now show clearer column headers with strategy names in bold and color-coded columns (blue, green, amber) to make it easier to compare multiple pricing strategies.

Each strategy in the comparison now has its own color (blue, green, or amber) with the strategy name shown above each column group, making it much easier to compare results at a glance.

Each pricing strategy's columns are now grouped together with a clear header showing the strategy name, making it easier to compare results across different strategies at a glance.

Each pricing strategy now has a clear header label spanning its columns, making it easier to compare "Proj %", "Δ pts", and "vs Current $/yr" values across different strategies without confusion.

Sensitivity scores now show the real number (like 56) instead of exaggerating tiny differences. The color still shows how it compares to similar stores, but only when we have enough data to be confident.

When you click the Strategy menu, you'll now find Strategy Utilities at the very top instead of at the bottom, making it faster to access common utility functions.

Removed confusing columns that compared one pricing strategy to another — now every strategy just shows its impact compared to what you're charging today.

Removed redundant dollar amount columns that showed both absolute values and comparisons to baseline. The comparison now displays only the "vs Current $/yr" columns for each strategy, reducing visual clutter and focusing users on the meaningful comparison metric.

The progress message when restoring your active strategy after a comparison now makes it clear this is a restore step, not another comparison run.

When the app restores your active strategy's prices after a comparison, the progress message now clearly explains what's happening.

Strategy comparison reports now show price sensitivity scores and blind percentages for each store, department, and class, helping identify where small price increases are safest.

Column headers in the Strategy Comparison grid now properly bind to strategy names (BaselineName, CandidateName, CandidateCName) and render them with consistent formatting: bold strategy name on the first line with text trimming for long names, and a semi-transparent metric label on the second line.

Removed redundant strategy name labels from individual column headers since the band headers now provide this context. Column headers now display only their metric type (e.g., "Proj %", "Δ pts"), making the grid more compact and easier to scan.

Each store, department, and class row now shows how many SKUs it contains in parentheses.

Each department and class now shows how many products it contains directly in its name.

The comparison screen now clearly labels margins as "Sitting %" so you know exactly what type of margin you're looking at.

Column headers now say "Sitting %" to make it clearer these are sitting margin percentages, not other types of margins.

Before running a pricing strategy, you'll now see a clear warning if any step has "Set to SKU" selected but the SKU field is empty, so you can fix it right away.

While applying corrections, a splash screen displays progress through each category (e.g., "Setting future prices: CP<MAP [1 of 3]"). After completion, the results message shows a detailed breakdown of items priced per category, or notes if any step was skipped due to missing data.

The Import Competitor Prices window shows you exactly what it found in your file before importing, and warns you to re-import after each POS data import since competitor prices are stored with POS data.

When you add or remove columns or selection box fields and save your changes, the "Set Future Price to" dropdown updates instantly to reflect the new available options.

You can turn automatic snapshots on or off using a checkbox in the Compare Strategies screen.

The grand total section now displays "Current:" instead of "Sitting:" to maintain consistent terminology throughout the screen.

Dialog messages now better explain what happens to your pricing data after a comparison and what each option does.

The confirmation dialog before running stale strategies now accurately describes the new restore behavior, explaining that the user will choose whether to reapply their active strategy rather than stating it will automatically rerun.

Hovering over a sensitivity score now shows both the easy-to-read relative score and the detailed absolute score with full breakdown.

Two new options are available in the Manage Custom Groups hamburger menu: copying groups from other strategies and finding duplicate SKUs.

You can now filter the SKU exceptions list to show only "Unassigned" rows—active exceptions that have no price level and never price anything.

The run summary will now tell you exactly which item is missing and remind you to edit your pricing group to choose a different price level.

The results message now shows exactly how many items were corrected in each category, making it easy to see what changed.

The ManagePricingStrategyV2View displays a read-only banner ("Shared strategy vN — read-only. Use 'Copy Current Strategy' to make an editable copy.") above the step list when the loaded strategy has a shared-strategy provenance marker. The step detail panel and bottom grid controls are disabled (IsEnabled bound to IsCurrentStrategyShared via BooleanNegationConverter). All mutating commands (add/edit/delete step, rename strategy, save changes) check BlockIfShared and show an informational message directing the user to copy the strategy first. The publish menu item is visible only when IsSupportMachine is true (gated on the ApplicationSettingsService flag set by CheckIsSupportMachine during startup). Strategy export, execution, activation, and backup remain fully enabled for shared strategies.

The "View by" dropdown is gone—just expand or collapse tree rows to see the level of detail you want.

The pricing panel now shows helpful guidance when you need to create a min/max strategy.

The Just Run flow now calls BuildSummaryAsync with the critical pricing predicate after loading the grid, so the Summary panel displays the count of items with Future Price <> 0 within the critical pricing set. This provides immediate feedback on how many violations have been addressed.

The Critical Retail Pricing documentation now describes "Just Run" as "Instant Correction" rather than "Instant Analysis," clarifying that the button applies pricing changes immediately and explaining that both "Just Run" and "Save as Strategies" produce identical corrections—the difference is timing (immediate one-time fix vs. automated workflow integration).

After importing, Margin Master asks if you want to add the imported competitor columns to your current view so you can see the prices right away — click Yes and they appear in the grid and selection boxes.

The import window now tells you how many items already have prices in each competitor field, so you can decide whether to add your prices or replace what's there.

When a file is loaded, the dialog queries the main tables to count how many items already carry values for each Comp level, displaying for example "101,391 of 106,565 items currently have a Competitor 1 price." This count appears next to the Replace/Add choice and is what makes the choice informed rather than blind. A note explains when existing values come from the POS (common on Epicor and Paladin). The query is non-blocking and the import can proceed even if the count fails.

Incomplete custom groups will now show a red error icon in the list, so you can see which ones need attention without opening each one.

The Manage Pricing Strategy dialog now displays a banner above the step list when the loaded strategy is a shared install ("Shared strategy v{N} — read-only. Use 'Copy Current Strategy' to make an editable copy."). All mutating operations (Add Step, Delete Step, Reorder, Edit Step, Delete Strategy) are blocked with a friendly message directing users to copy the strategy first or manage it from the catalog. Support machines see a new "Publish Shared Strategy" menu item; the dialog surfaces build-time warnings (view-dependent operands, missing groups/exceptions) and prompts for confirmation before uploading.

The pricing panel now shows a helpful message when no min/max strategies exist, with instructions on how to create one.

You can now filter the SKU exception list to show only entries with no price level set, making it easier to review what will be affected by bulk actions.

When at least one column is set to "Replace all existing values," the Import button shows a confirmation dialog stating how many existing prices will be erased and from which fields. This prevents accidental data loss. The dialog clarifies that values from the POS will return on the next POS import, but user-entered prices are not recoverable.

When the system automatically adds columns for a strategy, users now see a message identifying which strategy needed the columns and which ones were added. This prevents confusion from layouts silently rearranging and provides transparency about why the view changed.

The Strategy Comparison dialog includes an "Export to Excel" button that exports the comparison grid (all rows plus the grand total) to a spreadsheet, allowing users to share the A/B analysis with stakeholders or archive it for review.

The Compare Strategies window now starts with a list of all your strategies showing their status, making it easier to pick which ones to compare.

Comparison snapshots now prefer the strategy name (when available) over the custom label when displaying in the comparison picker and results grid, making it clearer which strategy each result represents.

The Strategy Manager displays a banner above the step list for shared strategies ("Shared strategy vN — read-only. Use 'Copy Current Strategy' to make an editable copy") and disables the step detail panel, bottom bar controls, and all mutating menu items. Support machines see a new "Update or Create Shared Strategy" menu item; all users see the "Get Premade Strategies" menu item in the main Strategy menu.

The Import Competitor Prices command is disabled in demo mode to prevent modification of sample data, consistent with other import and data-modification features.

After capturing a new snapshot, it automatically becomes the "Candidate (B)" compared against your previous snapshot as "Baseline (A)", making it easy to test a new strategy against what you were doing before.

Introduces two new local-only tables (StrategyResultSnapshot header and StrategyResultSnapshotDetail rows) that store labeled snapshots of the sitting-margin query. Each snapshot captures the current-price sales, future-price sales, and COGS at the Store/Dept/Class/Velocity/VendorOwned grain, preserving the exact dollar totals so they roll up to any grain (department → store → org) without rounding error. Snapshots survive the rebuild between two strategy runs and are never sent to the cloud. The tables are created automatically on first use via idempotent CREATE IF NOT EXISTS scripts.

Installed shared strategies write a provenance marker to GlobalFileConfig (Section=SHAREDSTRATEGY, Name=strategy name, Key=Origin) containing the template key, version, SharedStrategyId, and install timestamp as JSON. The presence of this marker is what makes a strategy read-only; the installer queries it to determine install state (not installed / current / update available) and the Strategy Manager queries it to enable/disable edit controls. Install and update operations trigger automatic strategy backups with reason "shared-strategy-install" or "shared-strategy-update".

Adds a DataVersion column to the StrategyResultSnapshot table to store the freshness stamp at capture time. Includes an idempotent ALTER migration for existing customer databases that were created before this feature. Pre-feature snapshots have null DataVersion and are treated as never current.

Adds a nullable DataVersion column to the StrategyResultSnapshot table to store the freshness stamp at capture time. An additive migration ensures existing customer databases pick up the new column. Snapshots captured before this feature (DataVersion = null) are always treated as Not Current.

Adds SharedStrategyModels.cs (SharedStrategyCatalogItem, SharedStrategyDefinition, SharedStrategyStep, SharedStrategyOrigin, PublishSharedStrategyRequest/Response) and three new API client methods: GetSharedStrategyCatalogAsync (filters by vendor type, returns metadata only), GetSharedStrategyDefinitionAsync (fetches the full body by template key), and PublishSharedStrategyAsync (upserts with machine-hash validation). The server stores definitions as opaque JSON blobs — only Margin Master parses RuleText, so step content can evolve without server changes. Rounding schemes travel only when not auto-seeded (KnownSchemeType schemes are skipped); the installer creates missing schemes but never overwrites same-name local schemes. Custom groups, SKU exceptions, and min-max strategies deliberately do not travel — they are store-specific.

Imported prices appear in your grid immediately and are saved with your POS data, but remember to re-import after each POS data import since that replaces the [Store] table.

The filtering logic is isolated in a new FuturePriceSetToLevelPolicy class with 107 lines of unit tests covering pseudo-levels, core levels, extended fields, view membership rules, Bloom Retail suppressions, and the removal of vendor/POS escape hatches. The policy receives a unified set of fields from both the column view and selection box view and makes purely functional decisions about each level's availability.

New `BuildTree` method in `StrategyComparisonMath` constructs the three-level hierarchy by grouping baseline, candidate, and optional third-candidate rows by store, department, and class keys. Each node applies the same sitting-margin and profit-delta calculations as the flat rows, ensuring exact reconciliation. Unit tests verify that store totals sum to the grand total and department/class children sum to their parent nodes.

Implemented a new ExecuteStrategyFromMenu command that wraps the core ExecuteStrategy method and explicitly marks runs as "Menu"-triggered. The system now defaults to marking runs as "Unattributed" instead of assuming they came from the menu, making it easier to identify and diagnose unexpected duplicate executions. This tracking also feeds into telemetry for better diagnosis of the rare duplicate-execution issue.

Added ShowModalSafeAsync method that ensures message boxes can be safely shown from any thread by first closing the splash screen verifiably (via EnsureSplashClosedAsync) and then marshaling the dialog call to the UI thread. This replaces unsafe HideSplashScreen calls that could not be verified and left modals unreachable.

Extracts the sitting-margin roll-up (gross profit / sales at current price and future price) from SittingMarginTelemetryService into a standalone static class, SittingMarginMath, and the Profit Analyzer's bucket SQL (the SELECT…GROUP BY that sums last-12-months sales/COGS into price bands) into SittingMarginQueryBuilder. This makes the sitting-margin calculation a single source of truth shared by the on-screen Profit Analyzer, the deferred telemetry post, and the new Strategy Comparison product, eliminating duplicated logic and ensuring all three measure identically. The shared valid-item filter excludes obvious pricing errors symmetrically for both current and future prices.

Every tree node—store, department, and class—computes its measures (projected margin, delta points, annual dollars) using the same dollar-weighted sitting margin math over its own subset of items. Each parent's totals exactly equal the sum of its children's totals, ensuring perfect reconciliation from class level up to store level. A new test verifies this reconciliation property.

Added BelowCostPriceDetector helper class that analyzes pricing rule text to identify below-cost scenarios: negative margins, cost-based pricing with subtractions (e.g., Store Cost minus 10%), and flat retail prices below item cost. The detector reads the stored rule text directly rather than UI state, following the same discipline as MissingPriceLevelDetector to ensure what's checked cannot drift from what's stored. Only certain shapes are reported to avoid false positives that would train users to click through warnings. Includes 106 unit tests covering all detection scenarios.

Each installed shared strategy writes a provenance marker (SharedStrategyOrigin: template key, version, server ID, install timestamp) into GlobalFileConfig (Section=SHAREDSTRATEGY, Key=Origin); the presence of this JSON is what makes a local strategy "shared" (static/read-only). Strategies without the marker — every pre-existing strategy — behave exactly as before. The publisher and the CheckMachine support-machine probe share the same machine-hash algorithm (SHA256 of "RS-SupportMachine-2024-Verify!" + uppercased machine name, lowercase hex); the server validates every publish request against the SupportMachine registry and returns 403 for non-support machines. Template keys are derived from strategy names (lowercase, trimmed, hyphen-separated) and serve as the upsert identity — publishing to the same key updates the existing shared strategy for all stores.

The dialog services for the Shared Strategy Catalog and Strategy Comparison views have been moved from MainMMViewModel to ManagePricingStrategyV2ViewModel, aligning with the UI reorganization. The frozen-surface contract test has been updated to reflect the removal of the two public methods from the main window's viewmodel.

Removed ShowSharedStrategyCatalog and CompareStrategies commands from MainMMViewModel and their associated dialog service registrations in MainMMWindow.xaml. These commands and dialogs have been relocated to ManagePricingStrategyV2ViewModel, streamlining the main window's responsibilities.

Implemented table-driven code-to-score mappings with generated SQL CASE statements, pinned by unit tests. Moving a code between rungs (e.g., adjusting DIB "E" from 50 to 25) requires only a one-number change in the map, automatically reflected in all SQL queries. Unit tests lock the contract: shared rung values, units-weighted math, null (never zero) scores when no assigned volume exists, additive roll-ups, and the blind/sensitive share and coverage companion metrics.

Introduced StrategyColumnRequirementPolicy to determine which columns a strategy requires based on its rules. The policy is deliberately minimal—it only requests columns when adding them would actually make a level usable, avoiding unnecessary layout changes. For example, it won't request Retail/Level1/Level2 columns at Bloom Retail stores where those levels are suppressed regardless of view settings. Includes 23 new unit tests covering boundary conditions and ensuring the policy adds exactly what's needed and nothing extra.

Extracted the sitting-margin bucket query (the SELECT…GROUP BY that aggregates last-12-months sales/COGS into price bands at current and future price) from ProfitAnalyzerViewModel into a standalone, reusable SittingMarginQueryService. The query logic now lives in SittingMarginQueryBuilder as a single source of truth, and the roll-up math (gross profit / sales) lives in SittingMarginMath, ensuring the on-screen Profit Analyzer, the sitting-margin telemetry post, and the new Strategy Comparison product all measure margins identically. Added comprehensive unit tests (StrategyComparisonMathTests) locking the A/B diff math: dollars are additive so overall = Σ store = Σ dept, the grand total is dollar-weighted (not an average of per-grain percentages), and candidate-vs-baseline dollars is the incremental profit the new strategy makes over the old one.

A new BulkAssignableLevelPolicy class defines which price levels the "Assign Price Level" action may offer. Only self-contained levels (Retail, Level 1, Level 2, CurrentPrice, StoreCost, vendor-specific levels like Ace_MSURetail, and zone levels) are offered; levels that require a per-rule value (Margin %, Fixed Retail, Cost Break, Set-to-SKU) are excluded because assigning them in bulk would recreate the exact "cannot price" state the action exists to fix. Unit tests pin this exclusion list.

Dropped the dead sync ExportRockSolid method, which carried a second copy of the concatenated DELETE/INSERT pattern with the same apostrophe and culture bugs. All export operations now route through ExportRockSolidAsync with the corrected, parameterized approach.

Introduces StrategyFreshnessService and StrategyFreshnessStamp to compute and validate freshness stamps. The stamp is composed from vendor catalog RowVersion (for Ace/DIB/EJ), POS ImportProcessing max date, and a SHA-256 content hash of the strategy's GlobalFileConfig rows (which have no modification timestamps). Unit tests lock the contract: snapshots with missing stamps are never current, and any component change invalidates the stamp.

Extracted the sitting-margin bucket query (the SELECT…GROUP BY that aggregates last-12-months sales/COGS into price bands at current and future price) from ProfitAnalyzerViewModel into a standalone, reusable SittingMarginQueryService. The query logic now lives in SittingMarginQueryBuilder as a single source of truth, and the roll-up math (gross profit / sales) lives in SittingMarginMath, ensuring the on-screen Profit Analyzer, the sitting-margin telemetry post, and the new Strategy Comparison product all measure margins identically. Added comprehensive unit tests (StrategyComparisonMathTests) locking the A/B diff math: dollars are additive so overall = Σ store = Σ dept, the grand total is dollar-weighted (not an average of per-grain percentages), and candidate-vs-baseline dollars is the incremental profit the new strategy makes over the old one.

Extended CustomGroupsService with new methods to support the copy and duplicate-finder features: GetGroupCountsByStrategyAsync returns the count of custom groups per strategy for the picker list; GetGroupsWithSkuCountsAsync loads all groups in a strategy with their SKU counts for the picker grid; CopyGroupToStrategyAsync performs the transactional copy of one group's settings and SKU list to a new GroupID in another strategy; GetGroupSkuRowsAsync retrieves all SKU memberships for duplicate detection; and RemoveSkuFromGroupAsync deletes a single (GroupID, SKU) row. Two new helper classes handle naming (GroupCopyNameHelper picks the next free "- Copy" variant) and duplicate detection (DuplicateSkuFinder groups SKUs by membership count and filters to those in 2+ groups).

Implemented source contract tests that verify all editing paths that reshape SKU exception rules properly notify the grid's derived columns (Type and FuturePriceAction). These tests prevent future code changes from reintroducing the same notification oversight by scanning the view model source for instruction mutations that mark the row dirty and ensuring they include the required property change notifications.

Added null checks and null-coalescing throughout the exception loading and migration code path to prevent any single malformed exception record from crashing the entire load. Null or empty RuleText fields are now handled gracefully, and null rows are filtered out before processing.

ExportService.View property type changed from TableView to DataViewBase (the common base class for both TableView and TreeListView) so Excel export now works for both flat grids and hierarchical tree lists.

Added 251 lines of tests in StoreRoutingKeyNormalizationTests to pin the meaning of empty store routing lists and prevent regression. Tests cover the exact incident scenario (store 12180), single-store and multi-store configurations with no groups defined, and all database shapes found across customer sites. Full test suite remains green at 1,502 tests.

New model classes (SharedStrategyCatalogItem, SharedStrategyDefinition, SharedStrategyStep, SharedStrategyOrigin, PublishSharedStrategyRequest/Response) define the wire format and local provenance structure. ApiClientService adds three endpoints: GET api/v2/SharedStrategy (catalog list filtered by vendor type), GET api/v2/SharedStrategy/{key} (full definition), and POST api/v2/SharedStrategy (publish with machine hash). SupportMachineHasher centralizes the SHA256(salt + MACHINENAME) computation used by both CheckIsSupportMachine and publish authorization. SharedStrategyInstallService and SharedStrategyPublishService encapsulate all materialization, validation, and round-trip logic. PricingStrategyService adds RegisterInstalledStrategyAsync to notify the cached strategy list of a directly written strategy without activating it. Comprehensive unit tests (SharedStrategyTests) pin the machine hash algorithm, template key derivation, provenance JSON round-trip, and catalog row state logic.

Added the CompareStrategies command to the MainMMViewModel frozen-surface contract test, keeping test expectations in sync with the new feature.

Updated the Ace Critical Pricing documentation to clarify that "Just Run" always analyzes every store and item, clearing any active selection-box filters first to ensure nothing is silently excluded from the compliance check. The previous docs incorrectly suggested prior selections would be respected.

FuturePriceSetToLevelPolicy tests now verify that MAP and IMAP are offered at Ace Hardware stores even with empty column views (the deliberate vendor exception for the Critical Pricing workflow), while other extended fields remain view-gated and non-Ace stores retain view-gating for MAP/IMAP.

The new CompetitorPriceFileReader class is deliberately free of WPF and database dependencies and is covered by 32 unit tests that pin the header-mapping logic, rounding rules, ignore-not-zero behavior, duplicate-SKU handling, and delimited-file parsing. Tests verify that headers are matched case/space/underscore insensitively, that column order doesn't matter, that unrecognized columns are safely ignored and reported, and that duplicate or missing required headers abort before any write occurs.

Added 183 lines of unit tests (`CompetitorPriceImportSqlTests.cs`) that pin the SQL generated for Replace (multi-table SKU matching, per-level clearing, COALESCE updates) and verify that only Replace-mode levels supplied by the file are cleared, that the clear is unfiltered so absent SKUs end up empty, and that SKU matching requires presence in at least one main table rather than just [Store].

Added RockSolidExportPreflightTests to verify each blocker condition is detected separately and produces distinct remedy text. Tests confirm shared file access is not reported as a lock (the false diagnosis this change removes), folder probes never touch the POS's .ldb lock file, and permission problems name elevation rather than closing the POS.

The Compare Strategies flow (showing picker, running strategies, showing results) is now orchestrated from MainMMViewModel.StrategyUtilities.cs using a post-close dispatch pattern (the hub dialog records the chosen action and closes; MainMMViewModel dispatches afterward), preventing nested modals. The comparison dialog service is now registered on MainMMWindow instead of ManagePricingStrategyV2View.

SharedStrategyInstallService materializes downloaded definitions into local GlobalFileConfig strategy rows, validates step parseability before writing anything, installs bundled rounding schemes only when no same-name scheme exists locally, and refuses to overwrite existing strategies or update/remove the active strategy. Warnings are collected for view-dependent operands (Comp1-5, Ace_MSURetail) that only resolve when the field is in the active column view, informing users of potential portability limitations.

Adds 379 lines of tests (CompetitorPriceFileReaderTests) pinning the import rules: header mapping by name not position, case/space/underscore normalization, decimal rounding, duplicate header detection, missing column validation, price parsing with currency symbols, and the "invalid values are ignored, never zeroed" contract.

Added SharedStrategyTests pinning the machine hash algorithm (must match server's SupportMachineService), template key derivation, provenance JSON round-trip, catalog row status logic, and definition JSON serialization preserving step order. These tests ensure the publish/download pipeline stays in lock-step with the server and that provenance markers remain readable across versions.

Adds a complete help article (docs/marginmaster/pricing/import-competitor-prices.md) documenting the file format, recognized column names, value parsing rules, import steps, how to use the imported prices in strategies and comparisons, the log format, and common questions. The article is indexed and searchable under "Pricing & Analysis".

If the RockSolid export fails, you'll now see clear instructions telling you to close RockSolid on all computers, check if the file is read-only, and verify you have permission to update files in that folder.

The Alternate SKU column now appears automatically in all your saved column views and cannot be hidden, since RockSolid requires this field for syncing data with your POS system.

Compass imports after the first one now complete faster by only loading changed items instead of reloading everything.

Error messages now show exactly which file couldn't be updated, making it easier to locate and fix permission issues.

The UPC lookup now runs one bulk query per export instead of two database queries per row, significantly improving export speed for files with hundreds or thousands of items.

Enhanced Store Manager query to order Epicor stores by their character ordinal value while non-Epicor stores continue to sort numerically when possible, ensuring consistent and logical store ordering in the grid.

Added three new FAQ entries covering whether stores should still build tunnels given the temporary nature, what ECI Connect is and whether it works with Margin Master, and how to request an earlier migration slot from ECI. Includes practical guidance that stores needing pricing data now should still build since the firewall purchase isn't wasted and only tunnel reconfiguration is required.

Added a tip to send WAN IP and subnet information in writing on the case thread and keep a copy, after a case where ECI stated they never received network details while the store believed they had sent them, causing a month-long delay. Updated technical details to note that server addresses are site- and era-specific and will change post-migration.

The first Compass import at a new store now completes cleanly without generating error reports.

If you're setting up Margin Master for the first time with Compass, the initial import will now complete successfully instead of failing with an error.

If a price export to RockSolid fails, you'll now see a checklist of all three things to verify, not just one, making it faster to find and fix the actual problem.

When you export pricing to a text file, the UPC column will now show the correct UPC codes for your products instead of all X's. If a product doesn't have a UPC in the system, it will still show X's as a placeholder, and the export will note how many products are missing UPCs.

When you used "Add From Catalog" to manually add a vendor SKU to your pricing grid, the item appeared to be added successfully but would disappear the next time you rebuilt your catalog. This is now fixed—manually added items will stay in your grid as expected.

Stores at Do-It-Best Epicor Compass sites now receive pricing from their correct RSC code instead of accidentally using another store's RSC when store numbers overlap with internal character codes.

File access issues during RockSolid export are now logged as warnings rather than errors, preventing them from appearing on the application error dashboard. This change recognizes that write-refused conditions are environmental issues on the store's machine, not application faults, consistent with how connectivity failures are already handled in cloud sync.

Store Manager now correctly displays all Epicor stores, including those whose store identifiers differ only by uppercase/lowercase letters (which represent different physical stores in Epicor).

Fixed an inverted logic condition that prevented the SKU and Store Group columns from being automatically added for Mi9 users when missing from a view. The force-add logic now correctly triggers when these columns are absent rather than when they are present.

Added validation when saving or copying column views to automatically append any missing required columns (such as Alternate SKU for RockSolid) to the end of the view. This prevents edge cases where saved view configurations could be persisted without mandatory columns.

The Alternate SKU column will automatically appear in your Main Table grid right next to the SKU column and will always stay visible.

The VPN setup guide now warns that ECI is moving to new servers — if you set up a tunnel now, you'll need to reconfigure it in a few months when the migration finishes.

If you try to hide the Alternate SKU column in Edit Columns, you'll see a message explaining it's required for RockSolid and the column will remain checked.

When customizing columns, you'll see a message if you try to hide the Alternate SKU column, explaining that RockSolid requires it to stay visible.

ECI has a new service called ECI Connect that might replace VPN tunnels, but we don't yet know if it will work with Margin Master — please let us know what ECI tells you about it.

Added a startup healing routine that detects and repairs existing databases missing the CreateDate default constraint on ManualCatalogItems table. The fix runs idempotently on every startup, ensuring all installations are automatically corrected without manual intervention.

RockSolid export failures caused by file permissions, read-only attributes, or locked files are now logged as warnings instead of errors. This prevents store-specific machine configuration issues from appearing on the application error dashboard as though Margin Master itself were broken. Genuine application failures continue to log as errors.

Enhanced MigrationBasedSchemaCreator to emit DEFAULT constraints for all model-defined defaults (both SQL expressions and CLR default values), preventing the same class of failures on future fresh database installations. CLR defaults are formatted as culture-invariant T-SQL literals to ensure cross-locale compatibility.

If your Ace zone assignments change at the corporate level, you can now use Options > Refresh Ace Zones in Store Manager to immediately update all your stores' zones without waiting for the next sync. The system will tell you how many stores had their zones updated.

Click Options > Refresh Ace Zones to re-check the assigned zone for all your stores against the latest Ace data. You'll see a summary of how many zones changed.

When new vendor or POS data arrives while you're working, Margin Master will now ask before restarting to apply it, instead of wiping your screen without warning. You can postpone up to 3 times if you're in the middle of something.

After a data update restart, Margin Master will automatically restore your grid selection and return you to exactly where you were before the update.

When you accept a data update, Margin Master saves what you have on screen, applies the update, and automatically reopens with your selection and pricing strategy restored.

You can postpone a data update up to 3 times. After that, it will be applied automatically to ensure your pricing stays current.

During the monthly catalog refresh, you'll no longer see a period where catalog data temporarily disappears from the system.

Scheduled monthly vendor catalog refreshes now happen seamlessly in the background. Pricing data remains accessible throughout the refresh instead of briefly disappearing.

If a data update runs while you're working, Margin Master now asks permission before applying it instead of disrupting your screen. You can apply it immediately, postpone it for 2 hours, or let it apply automatically after being postponed 3 times.

When sync issues occur, support staff will receive clearer information about what went wrong and how to fix it.

If the cleanup step encounters an issue, your pricing data will still sync successfully rather than failing the entire operation.

Extended the GetAceZonesToSync API method with a forceRefresh parameter that drops the 7-day cache, allowing manual refresh operations to fetch fresh data from the server while preserving normal cache behavior for automatic lookups.

Refactored zone resolution into a single LookupAceZoneAsync method shared by both the auto-fill-on-entry path and the new manual refresh command. This ensures consistent behavior: local AceStoreDepartmentZoneRecords rows are checked first (minimum zone across departments), and if the store isn't found there, the cloud API is queried. The forceRefresh parameter controls whether the 7-day cache is bypassed.

In the Data Aging screen, tables that failed their most recent sync attempt are now highlighted in red with an explanation, so you can tell the difference between "no new data" and "sync is broken".

Sync now completes successfully even if the cleanup step encounters an error. The data you need is synced correctly, and cleanup will be retried next time.

Data downloads now complete in the background even while you're working. Only the final table rebuild step waits for your approval.

If your Epicor store gets renumbered, your pricing data will rebuild automatically from existing import files without waiting for a new data import.

When an Epicor store is renumbered, the system now preserves historical POS data by moving staging table records, purchase order data, and the main table itself to the new vendor store number. This prevents data loss and ensures continuous pricing history across the renumbering event.

SyncStatistics now captures MaxRowVersionHex (the highest RowVersion synced) and TombstonesKept (count of soft-deleted rows retained locally) for each table sync. These metrics enable fast diagnosis of tables that appear to re-transfer the same rows on every sync—previously this required cross-database reconstruction to distinguish a regressing watermark from the producer re-stamping rows.

Post-sync verification now queries the view's input tables (DIBCatalogRecords and DIBPriceLevelRoundingDetails) directly instead of materializing the entire MMVendorData multi-join view. The old COUNT(*) FROM MMVendorData took 6.7 seconds and contributed the majority of total sync time on some stores. The new indexed checks run in ~16ms and detect the same failure condition (missing SchemeID=2 rounding rows).

Rebuilding the main table via catalog add (UPDATE-style rebuild) now skips the managed index rebuild when CreateTopPanel is also queued, since CreateTopPanel runs the identical rebuild pass moments later. This eliminates redundant index recreation and ~3 seconds of selection box cache rebuilding on every sync for DIB stores using per-store POS tables.

Sync operations will no longer fail with timeout errors when working with large vendor catalogs on slower computers.

The Do-It-Best EDLP price column in the pricing grid now correctly shows zero when EDLP pricing is not available, instead of displaying an incorrect calculated price.

When viewing Do-It-Best items, the "DIB EDLP" column was showing prices that looked real but were actually calculated from a pricing formula. Since Do-It-Best doesn't provide EDLP pricing, this column now correctly shows zero.

Catalog and zone pricing updates now always arrive, even when the vendor's database processes multiple updates simultaneously.

Fixed an issue where a store running newer Margin Master software would incorrectly detect data drift when syncing with an older cloud server. The newer client requests an active-only row count (excluding deleted records), but older servers silently ignore this flag and return a count including tombstones. The client would compare this inflated count against its own live count, conclude it was missing data, and force a full resync of the entire partition on every sync. This was particularly problematic for AceZoneRecords tables where 90% of cloud rows are tombstones. The client now returns -1 for "cannot answer" and skips validation rather than triggering unnecessary resyncs.

When vendor catalogs were being loaded while sync was running, some price or product updates could be skipped and never appear in Margin Master. This is now fixed—all updates will be captured, even during busy catalog import periods.

If your vendor gives you a new store number, the system will now automatically update all internal references after you enter it in Store Configuration. You'll no longer experience incorrect pricing due to mismatched store numbers.

If your vendor changes your store number, the system will now automatically update all internal records to match after you validate the new number. You no longer need to manually correct store mappings or worry about pricing at the wrong zone.

When vendors like Ace Hardware or Do-It-Best permanently remove products from their catalogs, those deletions will now correctly sync to your local database instead of leaving old records behind.

When syncing vendor data, you'll now see a notification listing any tables that failed to sync, even when other tables succeeded. Previously, these failures were invisible unless all tables failed.

VendorGTIN and catalog data now properly clean up deleted items during sync. Previously, items removed by the vendor would remain in your database indefinitely.

When you enter an Ace store number for a new store location, the Ace Zone field will now always populate automatically, even if that store hasn't been through a vendor sync yet.

When you type in a vendor store number for a new store, its Ace Zone now fills in automatically right away, even if that store hasn't gone through a vendor sync yet.

The sync no longer skips catalog rows that are being updated at the same time, ensuring all changes are captured.

Products with reassigned barcodes will no longer print extra labels showing old, retired barcodes.

Sync will now correctly continue until all pending changes are downloaded, even when the server is under heavy load and individual queries need to be retried with smaller batches.

SKUs with updated barcodes will now print only one label with the correct, current barcode instead of printing extra labels with old retired barcodes.

When you change a store's Vendor Store # in Store Manager, the change will now stick instead of reverting when you restart the application.

Changes to vendor store numbers in Store Manager now save correctly and persist across restarts.

Error messages during sync now accurately describe what went wrong instead of incorrectly blaming database connection issues.

After a temporary timeout, sync now correctly downloads all remaining changes instead of stopping partway through.

The system can now automatically detect and repair incomplete syncs for stores behind firewalls, improving data accuracy.

Stores using Epicor will no longer see duplicate store entries or incorrect zone pricing from leftover data tables.

Epicor stores will no longer show duplicate entries in reports or price incorrectly due to leftover old pricing tables.

When an older Manager version doesn't support the activeOnly flag on count queries, the proxy now returns -1 to signal "cannot answer" rather than an incorrect tombstone-inclusive count. This prevents false-positive drift detection that would trigger unnecessary full resyncs on every sync cycle.

Scheduled syncs now run more efficiently and avoid SQL errors that previously affected some Ace Hardware catalog tables.

Dropped references to the 'NoChanges' status value in sync history queries, as SyncStatisticsManager only ever writes 'Success' or 'Failed'. The Data Aging query previously filtered for both 'Success' and 'NoChanges', but the latter was never produced.

Fixed the Store table's composite index on [StoreNumber, SKU] (RSIX_Store_StoreNumberSKU), which was registered but never actually created due to a SQL guard that could not match multi-column definitions. The index now builds correctly on non-WestLake stores. Existing stores will have their stale seed definitions refreshed automatically. This index supports faster lookups when filtering the pricing grid by store and SKU together.

If a rebuild fails during the background apply phase, the parked work record is still cleared and the application is still relaunched. This prevents the user from being restarted in a loop on a rebuild that would fail the same way every time. The failure is logged to history where the user can see it, but they are not left without an application.

DIB stores using RockSolid, Transact, or non-MySQL Epicor build per-store main tables and never write to the global [mainTable]. The rebuild process now skips truncating [mainTable] and clearing SelectionLists for these stores, eliminating an unnecessary 3+ second selection box rebuild on every sync.

When vendors completely remove products from their catalogs, those products are now automatically removed from your local database during sync.

When vendors completely remove products from their systems (not just mark them deleted), those items are now properly removed from your local database instead of staying forever.

Syncs complete faster when no vendor catalog records have been removed, especially for large tables.

The cloud sync proxy now checks whether the server actually applied the activeOnly filter when counting rows. If the server response doesn't confirm the filter was applied (indicating an older Manager), the count is treated as unreliable and drift validation is skipped for that partition.

You'll now see a notification if any vendor data table fails to sync, even when other tables sync successfully. This helps catch partial sync failures that were previously invisible.

Removed vendor items and outdated catalog data are now automatically cleaned up across all vendor tables, preventing issues like printing labels with retired barcodes.

Reconciliation is deliberately opt-in via the ReconcileKeys flag because it reads every in-scope key from the cloud. For a narrow table like VendorGTIN (three columns, ~88k rows) this is negligible; for large tables like AceZoneRecords it would be expensive. The reconciler also refuses to act on an empty cloud key set, preventing catastrophic data loss if a network failure or truncated read returns zero records—it will not interpret that as "the vendor retired everything."

Reconciliation is opt-in per table via the ReconcileKeys flag because it reads every in-scope key from the cloud, which is inexpensive for narrow tables like VendorGTIN (~88k rows, 3 columns) but would be costly for large tables like AceZoneRecords. Added a safety guard that refuses to act on an empty cloud key set, preventing catastrophic data loss if a cloud read fails or returns no results.

The system now automatically detects and corrects incomplete vendor data downloads, even for stores behind firewalls.

Reconciliation executes on the "nothing changed" sync path as well as normal updates. This is critical: a hard delete bumps no RowVersion, so the sync where reconciliation needs to fire is precisely the one where the watermark reports zero rows to fetch. Both direct SQL and HTTPS proxy modes are supported; proxy mode pages through the existing rows endpoint requesting only key columns plus RowVersion.

Confirmed that the Do-It-Best FTP catalog feed contains only CTLD, PCD, PRDCD, EstimatedNetCost, and order/promo files—no EDLP or everyday-low-price data is provided. This validation ensures the system accurately reflects the vendor's actual data structure.

Updated store-manager.md documentation to describe the new Refresh Ace Zones feature and clarified that zone auto-population works for newly entered stores via cloud fallback when local sync data is unavailable.

Look for the new "Refresh Ace Zones" button in the Store Manager toolbar when working with Ace Hardware stores.

Failed table notifications now appear as non-blocking notifications rather than modal dialogs, because the sync splash screen is still visible and post-processing tasks are queued. A modal dialog would strand the background work behind the splash, preventing completion. The notification lists which tables failed and directs users to the application log for details.

The data aging screen now clearly marks when a table's sync date is stale because a later attempt failed. Look for red dates with "(last sync failed)" to identify ongoing sync issues.

The main view model now checks for parked rebuilds during background job polling, offers them when the pipeline is idle, and handles the capture/restore workflow. Consent prompts never interrupt active strategy runs or imports.

You can postpone a data update up to 3 times. After that, it will apply automatically to ensure your pricing stays current.

Added a new `PendingPipelineWork` table to store rebuild details (steps, strategy, selection, state) across the app restart that applies it. Steps are stored by name rather than enum values to survive build changes. Single-row table by design—newer parked work replaces older.

PendingPipelineWork table added to DatabaseTableCleanupPolicy's protected table list to ensure it is not inadvertently dropped during maintenance operations.

Created comprehensive tests to prevent regression of this issue. Tests verify that Level5 is set to zero for Do-It-Best items, that it does not source from the rounding ladder, and that Level3/Level4 continue to use the ladder as intended. This prevents a repeat of the MM-1354 issue where a ladder-calculated value was incorrectly placed in a vendor-specific pricing column.

Created ActiveRowCounter helper to centralize the "how many live rows exist for this scope" query used by both the count-validation pass and the reconciliation gate. This ensures both features measure the same thing, preventing silent failures where divergent SQL could cause reconciliation to skip when it should run.

A new headless command (`rebuild-and-restore`) applies accepted rebuilds and relaunches the app. Launched by the closing app itself rather than the Windows service, ensuring it runs in the user's session and can restore windows to their desktop even on locked or remote-desktop machines.

Added DibEdlpLevel5Tests to verify that the MMVendorData view assigns zero to Level5 and does not source it from the rounding ladder (np.Next3). The tests also verify that Level3 and Level4 continue to legitimately use the ladder, preventing regression of the MM-1354 fix for DIB Aux Retail.

Syncing large vendor catalogs (especially Orgill and Ace Hardware) will complete noticeably faster.

Cloud sync now runs significantly faster, especially for stores with large vendor catalogs.

Added comprehensive sync fidelity tests that reproduce the out-of-order commit race condition using overlapping transactions with different rowversions. Tests verify that rows are deferred rather than skipped when transactions are still in flight, and that all data is eventually synchronized once transactions commit.

Extended sync fidelity tests to cover reconciliation scenarios where the filter column is also a key column, which is the production configuration for VendorGTIN and DIBCatalogRecords. Tests verify both that reconciliation works under these conditions and that rows outside the filter scope are left untouched.

Added test case RowCommittedOutOfOrder_IsNotSkippedPastAndLost that reproduces the out-of-order commit race condition, verifying that rows committed out of order are deferred and delivered rather than permanently lost. Test fixture now enables READ_COMMITTED_SNAPSHOT to match production RS_CLOUD database settings.

Extended the ICloudSyncProxy interface and ApiCloudSyncProxy implementation to support counting active (non-tombstone) rows in a vendor catalog partition. This enables post-sync validation to verify that the local catalog matches the vendor's published data by comparing active row counts.

Added three new test cases covering hard delete scenarios: verification that hard deletes are invisible to standard watermark sync, validation that reconciliation correctly removes orphaned rows, and confirmation that reconciliation refuses to delete all local data when the cloud returns an empty key set.

Introduces PendingPipelineWork table and service to store rebuild jobs that are waiting for user consent. The table persists the queued post-processing steps by name (not enum ordinal) to survive application version changes across the restart boundary. Includes automatic table creation on first use, matching the pattern used for BackgroundJobStatus and BackgroundJobLock. Steps that no longer parse in the restored version are logged and skipped rather than causing a failure.

Added RebuildAndRestore headless command that applies a parked rebuild and relaunches the interactive application. This runner is spawned by the closing app itself (not by the Windows service) to inherit the user's session context, avoiding impersonation issues on locked workstations, multi-session machines, and remote desktop connections. The runner waits for the interactive presence marker to clear (up to 2 minutes) before touching any tables, ensuring the grid has fully released its handles.

When viewing the Strategy Execution Summary after a pricing run, you can now click "Copy Summary" to copy the entire report to your clipboard, making it easy to paste the information into an email, support ticket, or notes.

You'll now see a warning badge in the title bar when your data needs updating. It starts amber when vendor data gets old and turns red with a pulsing effect when your POS data is too old. Hover over it to see details, or click to update your data.

Look for a new "Data Aging" badge in the title bar. It appears amber when your data is getting old, and turns red and blinks when your POS data really needs updating. Click it to see details and update your data.

If you have an open issue but need to report a new but related problem, select "Submit a new issue related to this one" to keep them connected.

Created comprehensive documentation (pricing/lock-column.md) explaining all seven padlock icons, when the column appears, how to interpret blank cells, and common questions. Includes each icon rendered inline, technical details about the data source, and the relationship between icons and pricing rules. Also cross-references SKU-level exceptions and custom groups documentation.

Changes to default file paths in Settings now take effect immediately. You no longer need to restart Margin Master after updating Import Path, Export Path, or Network Import Root.

After changing your default import or export folder in Settings, all file dialogs will immediately use the new location—no restart required.

When deleting a database, you now type "delete" instead of the full database name to confirm the action.

The delete button's enabled/disabled state now re-evaluates with each keystroke in the confirmation box, providing immediate visual feedback rather than waiting for focus change.

When trying to delete the currently open database, you can now type in the confirmation box to see the full warning message. The Delete button will still be disabled to prevent accidental deletion of the active database.

If a strategy run has any problems, you'll always see the Execution Summary screen with the error details, even if you've turned off the after-run summary in settings.

Even if you've turned off the Strategy Execution Summary in settings, it will still appear automatically whenever a pricing run encounters errors, so you'll always know when something needs attention.

If you're a Do it Best store, the system now understands that vendor updates only happen on weekdays, so you won't see false warnings on Mondays after syncing on Friday.

The warning for outdated POS data now appears after 5 days instead of 1 day by default, which better matches typical store update schedules.

The console log now adapts its visibility based on setup outcome: it remains front and center while running and on failure (for troubleshooting), but on success it's hidden by default behind a "View Log" button to emphasize the success confirmation panel.

The setup console log now adapts based on outcome: it remains front-and-center during installation and on failure (when troubleshooting is needed), but is demoted to an opt-in "View Log" button on success. This prevents successful installations from feeling uncertain or incomplete due to log text dominating the final screen.

When selecting a database server, you'll see clear version names like "SQL Server 2025 Express" instead of confusing numbers.

The POS import history grid no longer shows confusing empty rows with "0 records" and placeholder dates from 2001.

The default threshold for POS data age warnings has been increased from 1 day to 5 days to better match typical import schedules.

When vendor sync finds no changes, the system now correctly recognizes your data as up-to-date instead of showing aging warnings.

Plain "Submit New Issue" with open issues now routes to Step 1 for duplicate checking. Direct updates via the issue pill or menu actions ("Update Issue") skip to Step 2 as before. The follow-up flow and startup mode continue to bypass Step 1 since they have explicit intent.

Support Scripts is now accessed from within the setup windows instead of the main Tools menu, making it available even when the database isn't yet configured.

The POS table fallback logic now skips tables with zero records, preventing empty tables from masking the "no POS data" condition. Previously, a table with zero rows could suppress both the fallback and the "never imported" warning, making the dialog appear as though data existed when it didn't.

For Do It Best stores, the system now understands that vendor data doesn't age over weekends, so you won't see false warnings on Mondays.

The delete button now responds instantly as you type, making it clearer when you've correctly entered the confirmation text.

Updated sku-level-exceptions.md and custom-groups.md with details on creating exceptions (via Sku Detail tab, not "Add Selected Sku to Custom Group"), added Ctrl+E shortcut, corrected window sizes and Export to Excel paths, documented save-time warnings, explained duplicate-wins rule and execution order, and added sections on the lock icon. Fixed incorrect references to tables/fields that don't exist. Added documentation for Copy Group from Another Strategy and Find Duplicate SKUs features in custom groups.

When comparing vendor catalogs, the sensitivity score columns will now display values instead of appearing blank.

When you assign a price level to an SKU exception, the Type column now immediately changes from 'U' (unassigned) to the correct type (R/M/D/etc.) instead of staying stuck on 'U' until you close the dialog.

One Click Statistics will now always display data, even if your current selection doesn't include any pricing tables.

Open and Save dialogs now always start in your configured default paths. Previously, they would remember the last folder you browsed to during your session, which could be confusing if you had configured specific default locations.

When you change your default import path, the automatic backup location now updates correctly to match.

When you fix an unassigned SKU exception and save, it now disappears from the "Unassigned" list right away instead of staying visible until you close the dialog.

The Print button in One Click Statistics now works correctly.

Fixed various property change notifications to ensure all UI elements (confirmation box, delete button, status messages) stay properly synchronized when database selection changes or deletion state updates.

Successful syncs now correctly update your "last synced" timestamp even when there are no catalog changes, so you won't see false warnings about stale data when you're syncing regularly.

Selecting the "New Issue" option in Step 1 now restores any pre-filled Title/Description (from error reports or diagnostics) instead of blanking the form, ensuring automatic diagnostic data isn't lost.

Fixed various property change notifications to ensure all UI elements (confirmation box, delete button, status messages) stay properly synchronized when database selection changes or deletion state updates.

When a strategy finishes, you can now click "Copy Summary" on the Execution Summary screen to copy all the details including any errors, making it easy to paste into an email or support ticket.

Before submitting a new issue, you'll see a list of your open issues first, helping you avoid filing duplicates.

When SQL Server setup finishes successfully, you'll see a clear green confirmation screen with the server name you can copy, instead of just a small banner that was easy to miss.

After SQL Server installs successfully, you'll now see a clear green checkmark and your database connection details, instead of scrolling through technical logs to confirm it worked.

When viewing SQL Server instances during setup, all buttons and information now fit on screen without needing to scroll sideways.

During SQL Server installation, you'll now see clear progress messages like "Downloading SQL Server 2025 Express" instead of technical console text. The technical log is still available under "Technical details" if needed.

When setting up SQL Server or running database scripts, you'll see clear step descriptions like "Installing SQL Server LocalDB" and "Configuring firewall rules" instead of scrolling console text.

If you need to reconnect to your database at startup, the connection window will now appear in your taskbar so you can easily find it.

The Support Scripts tool can now only be accessed from the SQL Server Setup > Tools menu, removing a duplicate menu entry that previously appeared in the database connection window.

When selecting a SQL Server instance in database utilities, you'll now see which version of SQL Server is running (like "SQL Server 2025 Express") to help you choose the correct server.

The Utilities menu is now organized into clear sections: diagnostics and logs at the top, data tools in the middle, and reset options at the bottom, making it easier to find what you need.

The Utilities menu is now better organized with related tools grouped together, making it easier to find the right tool and harder to accidentally click dangerous reset options.

When you open the Data Aging screen, you'll now see color-coded warnings: red banners alert you when POS data is old or missing entirely, and amber banners warn when vendor data needs a sync. These match the colored pill in the title bar.

When you open the Data Aging screen, you'll now see orange or red warning banners if your vendor or POS data is out of date, making it obvious when you need to sync or import fresh data.

The Data Aging warning in the title bar now shows a clock icon instead of a warning triangle, making it clearer that the alert is about outdated pricing data.

The Data Aging indicator now displays a clock symbol, making it clearer that it relates to how current your pricing data is.

Hover any padlock in the "*" column to see what it means. The column header also has a tooltip explaining the column's purpose.

Hover over any padlock in the "*" column to see exactly how that item was priced. The column header tooltip now explains what the column is for.

Support Scripts is now found in the Tools menu of the SQL Server Setup and Database Setup windows instead of the main window's File menu.

The technical console log is now hidden by default to keep the screen simple, but automatically appears if something goes wrong so support can troubleshoot.

The prompt text in the Delete Database window was updated from "Type the database name to confirm deletion" to "Type the word delete to confirm" to reflect the new confirmation method.

The confirmation text box in the Delete Database dialog is now disabled when the selected database is the currently active one, making it visually clear that deletion is not possible. Previously, users could type the confirmation text even though the delete button would remain disabled.

The Communications Tester utility has been moved from the middle of the menu to the diagnostics section alongside log file tools, since it serves a diagnostic purpose rather than a data management function.

If you've never imported any POS data, the screen now shows a clear message explaining that you need to import your point-of-sale data to see sales and margin information.

Restored the header tooltip for the "Z" (zone pricing) column, which was being lost when the header was replaced with the bare "Z" symbol. Now reads: "Zone — vendor zone pricing applies to this item."

Hover over the "*" or "Z" column headers to see what those symbols mean.

Enhanced path configuration across multiple screens including Main Window, Cost Break, Custom Groups, Pricing Strategy, Rounding Editor, Rounding Scheme Check, and SKU-Level Exceptions to ensure consistent behavior when working with import/export operations.

Applied the instant path update behavior to file dialogs in Cost Break, Custom Groups, Pricing Strategy, Rounding Editor, Rounding Scheme Check, and SKU-Level Exceptions screens. All now respect updated default paths immediately without storing previously-selected directories between sessions.

Added a ToggleLogCommand and ShowLogDetails property to allow users to reveal the full console log on the success screen when needed, supporting power users who want to review what happened without cluttering the default experience.

If you need to install or configure SQL Server during first-time setup, you can now access SQL Server Setup directly from the Database Setup window's Tools menu.

The "SQL Server Setup" menu option and window are now called "SQL Server Tools" to better reflect all the database management tasks you can do there.

Updated tooltips on the Miscellaneous options screen and the summary screen's checkbox to clarify that runs with errors always show the summary. Documentation now includes a complete section on the Strategy Execution Summary screen with button descriptions and behavior details.

The Database Setup window now includes a "SQL Server Setup..." option in its Tools menu, ensuring that users on brand-new machines (with no SQL instance and no database) can always reach the guided SQL installation wizard from the initial setup screen.

When enriching POS import history from main tables that lack a LastUpdate column, the CreateDate now displays as "—" instead of "01/01/01 12:00 AM", which was confusing and appeared to be corrupt data.

Updated the Data Aging group box label in Tools > Options > Miscellaneous to clarify that the thresholds control when the title-bar warning appears, making the connection between the setting and the new visual indicator clearer to users configuring their preferences.

After submitting a related issue, you'll see confirmation showing which issue it's connected to.

If you select the database you're currently using, the confirmation box is now grayed out to show you can't delete it.

The "SQL Server Setup" feature has been renamed to "SQL Server Tools" to better describe what it does.

Implemented LockIconDescriptionConverter as the single source of truth for tooltip wording, with comprehensive unit tests (LockIconDescriptionConverterTests) that fail if a new icon is added without corresponding tooltip text. The converter returns null for values with no icon (NULL, 'N', 'U'), ensuring blank cells show no tooltip.

The DataAgingIndicatorPlanner.Result record now includes VendorIsStale and PosIsStale boolean flags, making it easier for the Data Aging dialog to determine when to show banners without re-evaluating thresholds. Unit tests added to verify the flags match the existing ShowWarning and IsAlarm logic.

Extracted a new DataAgingIndicatorPlanner class containing pure, side-effect-free computation of the warning pill's visibility, alarm state, and tooltip text. The planner is fed from application settings and returns a decision record, with 166 lines of unit tests pinning the behavior including threshold comparisons (age >= threshold warns), weekday-only calculations, never-synced cases, and tooltip wording.

A new ScriptOutputParser service uses regular expressions to detect phase headers (>> Step N: ...) and heartbeat lines (still working: label (m:ss elapsed)) from PowerShell script output, enabling the UI to translate technical console streams into structured progress information. The parser scans each appended chunk of output and extracts the last phase and heartbeat label found, which view models then bind to UI elements.

Created DataAgingIndicatorPlanner as a pure, side-effect-free calculation engine for all data aging indicator decisions. The planner is fully covered by 15+ unit tests that pin the exact behavior for threshold comparisons (inclusive), weekday-only vs. calendar aging, never-synced scenarios, tooltip construction, and click-hint display. This separation ensures the title-bar indicator and the Data Aging dialog can share identical logic.

The DataAgingIndicatorPlanner.Result record now includes VendorIsStale and PosIsStale boolean flags, allowing the Data Aging dialog to share the exact same staleness logic as the title-bar aging indicator. This ensures both UI elements always agree on whether data is current or needs attention.

Added comprehensive unit tests for BuildSummaryText and HasStepProblems methods, covering successful runs, terminated runs, and various error conditions (load failures, exceptions, no matching data). Tests verify that all error details are included in the copyable summary text.

Added comprehensive unit tests that verify the Copy Summary button includes all error details (missing selection values, rounding schemes, step exceptions) and that the HasStepProblems logic correctly identifies when a run must show the summary despite user preferences.

Added source-level contract tests that verify any code path that reshapes an SKU exception's pricing rule and marks it dirty also notifies the derived "Type" and "Set Future Price to" columns. This prevents future edits from introducing the same display bug.

Added comprehensive documentation (docs/marginmaster/pricing/lock-column.md) explaining the lock icon system: what each of the seven padlock symbols means, when they appear, how to interpret blank cells, and how locks relate to SKU-level exceptions and custom groups. Includes a visual key with all seven icons, common questions, and technical details for support.

Added ScriptOutputParser service that scans PowerShell setup script output for structured markers: ">> Step N: ..." phase headers (from Write-Step) and "still working: label (m:ss elapsed)" heartbeat lines (from Invoke-ChildProcess), converting them into friendly CurrentPhase and PhaseDetail properties for display.

Updated sku-level-exceptions.md and custom-groups.md to explain how exceptions and groups interact with the lock icon system, including new sections on "How exceptions run," "The lock icon on the main grid," and expanded troubleshooting for duplicate exceptions and below-cost pricing warnings.

Added lock icon keywords to the search index (lock icon, padlock, star column, asterisk column, etc.) and updated main-window-orientation.md to include a section explaining the two narrow symbol columns ("*" and "Z") with a reference to the new Lock Column page.

Removed the legacy VerifyDataAging() method from MainMMViewModel, which had zero callers and implemented an older daily-check pattern. The new title-bar indicator replaces this functionality with continuous passive monitoring.

Retired the VerifyDataAging method that previously showed blocking modal dialogs at startup when data was stale. The new always-visible title-bar indicator provides continuous awareness without interrupting the startup flow, and users can click the pill to access the full Data Aging dialog when needed.

When an update download completes but doesn't take effect on restart (a "swap no-op"), the system now checks whether this is the first attempt for that version or a repeated failure. A first no-op is logged as a warning locally, since the swap usually completes on the next launch. Only when the same target version fails again does the system escalate to an error report on the support dashboard. This change was driven by observing store machines that reported update "failures" on every release cycle yet consistently arrived at each new version within days — their install directories weren't locked, the swaps were simply deferred.

The export process now logs a warning when SKUs have no UPC code available in either the VendorGTIN or Store tables, showing how many rows were affected. These rows still export with the "XXXXXXXXXXXXXX" placeholder, but the log now provides visibility into data quality issues.

When you export pricing data to NEWRETAILS.txt or other text formats that include UPC codes, the file will now contain the actual UPC numbers instead of showing "XXXXXXXXXXXXXX" for every item.

When printing or exporting to Excel with the "Use Current Price when Future Price = $0.00" option selected, all product information (SKU, description, cost, etc.) now appears correctly instead of showing blank rows.

When exporting to Excel with the "Use Current Price when Future Price = $0.00" option checked, items will now show all their data correctly instead of appearing as blank rows.

When an update apply fails immediately (before the restart), the system now clears the pending-update sentinel and records the failure at the correct location. Previously, a sentinel written before a failed apply would persist and cause the next launch to misclassify the failure as a locked install directory for a swap that was never attempted. This fix applies to all apply paths: the startup version gate, the database setup window's "Download and Install Now" button, and manual update checks from the Help menu.

The system now clears provably outdated failure states before deciding how to classify the current launch's update outcome. When a machine reaches the version it previously failed to install (via repair install, manual installer, or the background service), the old failure counter is reset before the current launch evaluates whether to report a problem. This prevents a machine that has already healed from incorrectly coloring the current launch's verdict.

Changed the UPC resolution logic from running two database queries per exported row to a single bulk lookup that processes all SKUs at once in batches of 1,000. This eliminates hundreds or thousands of individual queries during export operations and dramatically improves export speed for files containing UPC columns.

Removed obsolete commented-out code from a previous implementation and enabled nullable reference type checking in the PrintViewModel to improve code quality and catch potential null reference issues.

When you start Margin Master, it now cleans up your database history by removing entries for databases that have been deleted from the server, but only when it can verify the server is still available.

Enhanced the STORERSC loading logic in the Store Manager to match the same duplicate-handling pattern already used for other configuration entries (existingByOrdinal). This ensures consistent and reliable configuration loading even with imperfect source data.

Modified the BuildUpcLookup fallback query to exclude Store rows with NULL or empty UPC values in the WHERE clause. This prevents Entity Framework from attempting to materialize NULL database values into non-nullable string properties, which was the root cause of the exception.

If you have multiple connection history entries for the same local database server (due to different naming like "localhost" vs your computer name), these are now automatically combined into a single entry.

Compatibility level checks and automatic adjustments now recognize that Azure SQL supports level 160 regardless of its reported 12.0 product version, ensuring optimal query performance for Azure-hosted databases.

Both splash screen teardown paths now call SplashScreenManager.CloseAll(force) to guarantee cleanup of any orphaned splash windows, matching the ground-truth force-close approach already used in the async ensure-closed method. The close verification logic was enhanced to check both the service state and the static ActiveSplashScreens registry, ensuring that an orphaned manager (one the service has detached from but is still showing a window) keeps the watchdog timer armed for retry attempts.

Loading screens are now more reliably dismissed when operations complete, even in edge cases.

The strategy summary dialog now shows your sitting margin and profit impact numbers right away instead of displaying "Calculating..." while you wait.

Existing databases with accumulated performance-draining indexes will be automatically cleaned up when the application starts.

Items with recent Mi9 price changes now stay flagged for 60 days after the change takes effect, making it easier to identify recently-changed items in strategies and filters.

Daily database optimization now focuses on indexes where defragmentation actually improves performance, completing faster.

Database maintenance now skips very small indexes that don't benefit from rebuilding, reducing startup time and avoiding unnecessary database locks.

The index seeding system now detects when a registered index definition has drifted from the current correct version and automatically updates it. This ensures the fleet repairs itself on first startup after update without requiring manual intervention or database scripts. Only affects seed indexes; DMV and SelectionBox-registered indexes are never modified.

When optimizing the database, you'll now see two separate messages: one listing obsolete Margin Master tables you can safely remove, and another listing any tables this version doesn't recognize (which won't be touched at all).

When running database cleanup, you'll now see clear explanations of which tables can be safely removed and which ones the software doesn't recognize, with guidance on what to do.

Introduced MainTableSelectionPolicy with 267 lines of tests pinning the exact behavior that prevented store 12180's incident, including how Mi9 single-table mode short-circuits, how grouping fallback resolves, and how leftover Mi9_mainTable tables are ignored in multi-table mode. The policy centralizes logic previously duplicated across DatabaseService1 and StoreDataService with subtle differences.

Auto-updates will no longer turn on the background service if you had it turned off.

Consolidated the schedule migration logic into a single implementation that runs at startup rather than maintaining separate copies in the Options tab. This prevents the two implementations from drifting apart and producing different migration results for the same store.

The automatic strategy-comparison snapshot capture (used for before/after analysis) is now awaited during the "Preparing summary..." phase instead of running in the background. This prevents the snapshot from racing with any user actions after the strategy completes, ensuring it captures a consistent view of the pricing results.

Added a showSplashOnReload parameter to SaveOrUpdateStrategyToActiveStrategyAsync so callers performing multiple consecutive saves (like Ace Critical Pricing three-step conversion) can suppress intermediate splash displays. Defaults to true (show splash) to preserve existing behavior for single saves.

When viewing the Strategy Execution Summary after a run, sitting margin and profit impact numbers now appear immediately instead of calculating in the background.

Sync and import operations will no longer get stuck repeatedly attempting to build indexes that cannot complete on your system.

You can now see the exact date when a Mi9 price change took effect or will take effect by adding the "Mi9 $ Effective Date" column to your pricing grid.

Wrapped the OptimizeDatabaseIfNeededAsync call in the heavyPipelineGate semaphore to serialize it with startup sync and strategy runs. The ALTER INDEX REBUILD operations target the same main tables that sync's SyncMainTableCostFields updates, and when the two overlapped SQL Server would pick one as a deadlock victim. Observed cost on 2026-08-20 was 37 seconds lost on a single index rebuild plus retry backoff. The gate already serializes strategy runs against post-processing for this reason; maintenance belongs behind it too.

Introduced MainTableSelectionPolicy as a pure-static testable class that centralizes the logic for choosing which main tables to read. All six decision branches are now covered by unit tests pinning the exact customer scenario (Ace store 12180's database state), preventing this class of regression. The policy replaces duplicate code in DatabaseService1 and StoreDataService that had already diverged (StoreDataService was missing the Mi9 single-mainTable guard).

When viewing changed items after a strategy run, you'll see a "Loading changed items…" message right away instead of a frozen-looking window.

Modified the snapshot capture process to accept pre-computed sitting-margin rows, so callers that need the data for multiple purposes (snapshot storage and summary display) only pay for the expensive scan once. The StrategyComparisonService now provides an overload that accepts already-fetched rows.

The startup progress bar now moves smoothly during database optimization instead of jumping around.

Table names containing '*' (database corruption) are now filtered out before checking if the list is empty, so a database whose only match is corrupt gets the last-resort fallback instead of an empty list. This ordering is verified by a unit test.

Margin Master will no longer crash at startup if your store configuration accidentally contains duplicate RSC assignment records. The application will use the first assignment it finds and continue loading normally.

The application will no longer crash at startup if your configuration files have duplicate RSC assignment entries for the same store.

The SQL Express setup wizard will no longer crash on newer computers with NVMe solid-state drives, and will properly detect when special compatibility settings are needed.

Fixed a PowerShell array handling issue in the disk sector size detection code that would cause the SQL Express installer and upgrader to crash on systems with strict PowerShell mode enabled. The scripts now properly handle the return value when checking for disks with physical sector sizes larger than 4KB, which is important for SQL Express compatibility.

Fixed a crash that could occur when printing labels for items that don't have UPC codes in your store's database.

Fixed an issue where the price level dropdown could fail to update properly when switching between pricing views, especially during background operations. The list will now refresh correctly in all scenarios.

Switching between views while working with future pricing will no longer cause the application to crash unexpectedly.

If you previously experienced errors when trying to install or upgrade SQL Server Management Studio from the Setup window, this issue is now resolved. The installation scripts are now properly included with the application.

Fixed a rare issue where quickly double-clicking the Close button in the SQL Server Setup window could show an error message, even though the window closed properly.

The SQL Server Setup window will no longer crash if you accidentally click the close button or X multiple times quickly.

If your store uses Azure SQL Database, you will no longer see daily warnings that your SQL Server is outdated.

When running a pricing strategy, the app will now stay unavailable until the entire process completes and you see the summary, preventing accidental clicks that could interfere with the calculations.

You won't see brief flickers where the app becomes clickable during a strategy run anymore — it will stay locked with the progress screen until all pricing is fully calculated and ready.

After saving Ace Critical Pricing items as pricing strategies, the app will no longer freeze with an unresponsive main window requiring a force-quit.

If you saved Ace Critical Pricing settings as pricing strategies, a loading screen could get stuck on your screen and block all mouse and keyboard input, forcing you to close Margin Master from Task Manager. This no longer happens.

Pricing updates and strategy runs will complete much faster, particularly for multi-store groups—one affected store saw zone pricing speed improve from 5 minutes 48 seconds down to 915 milliseconds.

When you run custom groups, the execution summary will now correctly show whether rounding was applied and how many items were changed, making it easier to verify that your pricing updates ran as expected.

After running a custom group or SKU exception that applies rounding, the execution summary now correctly shows which rounding scheme was used instead of showing blank.

When you click Execute Strategy or press Ctrl+X, the pricing run now starts immediately instead of asking you to confirm. The confirmation dialog will only appear if the system detects a suspicious automatic re-run.

Startup database maintenance will now complete faster and won't repeat the same work every day.

The application will start faster when database maintenance is needed, especially on larger databases. The maintenance process now completes in one pass instead of having to repeat the same work every day.

The RSIX_Store_StoreNumberSKU index, which enables fast lookups by store number and SKU, was never actually created on any database due to a SQL generation bug. The CREATE statement included a guard clause that checked for a column literally named "[StoreNumber],[SKU]" instead of checking for both columns separately, causing the statement to succeed as a no-op while logging "1 created" on every startup. The index is now written longhand and will be automatically created on first startup after update. This index improves performance for store-specific SKU lookups on non-WestLake databases.

If the database cleanup finds tables it doesn't recognize, it will now show you the list and explain that they won't be touched, rather than offering to delete them.

If you use "Optimize Database," the cleanup will now only remove tables from old features that are no longer used. Any tables it doesn't recognize will be shown to you in a message but will never be deleted automatically.

If you turn on "Use Store Grouping" in Options before creating any groups, your selection boxes will still work—the system will use your store's real data and show a warning in the logs.

If you had store grouping turned on in Settings but never created any groups, the pricing grid would show no items and pricing strategies wouldn't update anything. Now the grid and strategies will work normally using your store's data, and a warning will remind you to either set up groups or turn off grouping.

If you accidentally turned on "Use Store Grouping" without setting up groups, your selection boxes will now work correctly instead of appearing empty.

If an auto-update tries to install while a background import is running, it will now wait and retry on the next launch instead of silently failing to update.

Previously, the migration that converts old separate vendor and POS schedules into the unified Data Update schedule only ran if someone opened the Background Service tab in Options. Since the new Data Update keys default to OFF, stores that upgraded without visiting that screen would silently stop running overnight data updates. The headless service couldn't recover on its own because it only launches when a schedule is active. Now the migration runs on every application launch, both interactive and headless, ensuring all stores migrate successfully.

Your overnight data updates now migrate automatically when Margin Master starts, so vendor catalogs and POS imports continue running on schedule even if you never open the settings screen.

The progress bar during strategy runs now correctly shows how much of the entire process is complete, rather than jumping to 100% while steps are still running.

The progress bar during strategy runs now shows accurate overall progress instead of jumping to 100% while steps are still processing.

Items with price changes from Mi9 will now stay flagged as "recently changed" for 60 days after the change takes effect, so your REMOVECHANGE rules will properly protect those prices for the full two-month window.

Long sync operations are now more reliable and won't cause network connection issues on the store computer.

After sync completes, dropdown lists (like SKU selection) now populate instantly instead of taking several seconds to reload.

The Store dropdown will now populate correctly for all configurations.

The automatic strategy-comparison snapshot (when Auto Capture Strategy Results is enabled) now completes fully under the "Preparing summary…" splash instead of running in the background. This prevents the snapshot from reading FuturePrice values that could change if the user started another action immediately after the summary closed.

Startup will no longer occasionally pause for 30+ seconds when database maintenance and cloud sync run at the same time.

Resolved an issue (MM-1398) where scheduled full refreshes were running orphan cleanup on all Ace Hardware tables simultaneously, causing SQL ambiguity errors (SQL 209) on tables where the filter column is also a key column. The sync service no longer force-enables reconciliation during scheduled refreshes since it's now enabled by default with appropriate safeguards.

Selection boxes that appeared empty due to a temporary configuration issue will now automatically populate correctly after the issue is resolved, without needing manual database cleanup.

After closing the strategy summary, you'll see a "Loading changed items..." message right away instead of a brief moment where the screen appears frozen without explanation.

If selection boxes are empty due to missing data, restarting the application or rebuilding will now correctly re-scan them once data is present.

Fixed GetGroupList to filter out per-store main tables when store grouping falls back due to missing group tables. Previously would attempt to parse store numbers as group names, creating invalid group entries.

If the migration encounters a transient error (such as database connectivity issues), it deliberately does not mark itself as complete. This allows the migration to retry on the next application launch rather than leaving a store permanently unmigrated and unable to perform background updates.

GetGroupList now filters to only StoreGroup_{group}_mainTable tables using IsStoreGroupMainTable. Without this filter, the grouping fallback list (which can now include per-store tables like Epicor_12180_mainTable) would have split the table name and invented a store group named "12180".

A multi-table Mi9 store caught mid-restructure with a leftover Mi9_mainTable would have double-counted it alongside the real per-store tables (it matches LIKE '%mainTable'). The policy now explicitly excludes the Mi9 single-table name unless the store is actually in single-table mode.

All vendor catalog tables now automatically remove records that vendors have deleted from their systems, preventing issues like printing labels with outdated barcodes.

Configured the HTTP connection pool with a 10-minute lifetime to balance connection reuse with server-side resource management. Extended the overall request timeout to 5 minutes to accommodate large catalog downloads.

A new "Mi9 $ Effective Date" column shows exactly when a price change took effect or will take effect, separate from the yes/no flag.

Changed the Strategy Execution Summary dialog's sitting margin and profit impact lines from "Calculating..." to "Not calculated" as the default state, accurately reflecting that these metrics are only available when strategy comparison auto-capture is enabled.

The progress bar during database maintenance now moves smoothly from start to finish instead of jumping around.

Eliminated the 500ms artificial delay that was previously added between each selection box tab during startup, providing a faster and more responsive initial load experience.

The System Diagnostics screen now correctly displays Azure SQL edition information when showing database version details.

Curated a list of tables from retired features that have been proven to have no remaining readers: legacy Sync Framework artifacts (scope_info, scope_config, schema_info), retired sync-tracking tables (MMVendorData_tracking, VendorGTIN_tracking, Ace_ZonePrice_tracking, Ace_ZonePrice, Ace_Current_tracking), replaced tables (Ace_Levels), and removed features (DIB_Costs). Each entry has been verified to have no creator that still runs and no reader anywhere in the codebase.

Removed the daily startup sitting-margin telemetry submission (which full-scanned every main table 12 seconds after the splash screen closed) and the post-execution cloud posting. Cloud sitting-margin posting will be moved to the Windows service to run on a schedule without impacting the desktop application's responsiveness.

Switched from per-request HTTP clients to a single shared client backed by a SocketsHttpHandler with a 10-minute pooled connection lifetime. This allows DNS changes to be picked up periodically while maintaining connection reuse benefits. Bearer tokens are now set per-request rather than as default headers to safely handle token refreshes during long-running sync operations.

The BuildMMVendorDataViewAsync method no longer returns a row count that neither caller was reading. The expensive query that produced this unused number has been eliminated, and the method signature changed from Task<int> to Task.

Instead of hand-typing POS prefixes into a static list, the cleanup policy now derives them directly from PointOfSaleSystemTypeEnum, so a newly supported POS system automatically protects its tables—{POS}, {POS}_{store}_mainTable, {POS}_bcp, etc.—the same day it's added. Comprehensive unit tests walk every table name created by SqlTableCreationScripts and every POS in the enum, ensuring no live table can silently fall out of protection if the schema changes.

Introduced DatabaseTableCleanupPolicy with comprehensive unit test coverage that prevents the allowlist from drifting out of sync with the schema. The policy automatically derives POS table names from PointOfSaleSystemTypeEnum and cross-checks created table names against SqlTableCreationScripts. Two "drift guard" tests ensure newly added tables or POS systems are automatically protected without manual list maintenance.

Applied the same fix to both DatabaseService3 and StoreDataService to prevent the two implementations from drifting, ensuring consistent behavior across all consumers of main table resolution.

Created a new test suite pinning the 1,000-page minimum and 30% fragmentation threshold. The tests document the regression origin (Aubuchon Mi9, 2026-08-20: 110s rebuilding 54 indexes, 13 of which were too small to benefit) and verify boundary conditions at exactly 999/1000 pages and 30.0/30.1% fragmentation. IndexMaintenancePolicy is a pure static class matching the pattern established by ImportFolderCleanupPolicy.

Margin Master will no longer slow down after running pricing strategies or when first starting up in the morning. Background calculations that were making the app unresponsive have been removed.

Strategy runs no longer trigger slow background calculations. The Strategy Execution Summary dialog still shows current and future sitting margin plus profit impact, but now displays "Not calculated" when auto-capture of strategy results is disabled in settings.

Index seeding now uses a single database connection and pre-reads existing index names before inserting only missing entries, replacing the previous approach that opened a new connection for each index (~276 connection roundtrips on a 23-table store). This eliminates a significant startup bottleneck when all indexes already exist.

Changed the critical index seeding process to register all indexes in a single database connection instead of opening a new connection for each index. Previously, stores with 23 main tables would make ~276 separate database connections during startup just to check index registration status. The system now builds the full index list first, reads registered indexes once, and inserts any missing registrations in a single batch.

Cloud sync operations now use less internet bandwidth and may complete faster, especially when syncing large vendor catalogs.

Cloud sync operations now transfer less data over the network, making syncs faster and more efficient, especially for large vendor catalogs.

Syncs finish several seconds faster—the health check at the end of each vendor sync now completes almost instantly.

Scheduled vendor catalog syncs now finish much faster. Stores with large Ace Hardware catalogs will notice the most improvement, with sync times reduced by 30+ seconds in many cases.

Applied the comma operator prefix to array returns in disk detection functions, matching the pattern already used in Invoke-SqlQuery. This ensures arrays remain intact across PowerShell versions and strict-mode settings in both Install and Upgrade scripts.

Updated the Get-LargerThan4KSectorDisks function in both install and upgrade scripts to use the comma operator for proper array wrapping, preventing unwinding of single-element arrays that triggered errors in strict mode. This ensures the database installation process completes successfully across all PowerShell configurations.

Created comprehensive tests that verify all setup scripts referenced by the Guided SQL Server Setup window and Installation Scripts dialog are correctly embedded as resources. These tests check for Install-SQLExpress.ps1, Upgrade-SQLExpress.ps1, Install-SSMS.ps1, Upgrade-SSMS.ps1, Uninstall-SSMS.ps1, Uninstall-SQLServer.ps1, Set-ExecutionPolicy.ps1, Install-DotNetRuntime.ps1, and Install-OleDb12.ps1. The build will now fail immediately if any script is missing, preventing this class of silent deployment failure from recurring.

The application no longer runs a lengthy background calculation shortly after startup, improving responsiveness when you begin working.

The "BLANK" option check for each selection box field is now persisted in the SelectionLists cache table during initial build, eliminating the need to scan every main table on warm starts. The cache is automatically cleared when data changes, ensuring accuracy while dramatically reducing repeated database scans during startup.

Selection box lists (Department, Vendor, Category, etc.) now persist their "BLANK" option status in the cache database, eliminating the need to probe every main table for blank values on warm startups. The blank value check (a UNION scan across all main tables) now only runs when the list is freshly rebuilt from actual data, not when loading from cache.

Added "Unattributed" as an explicit trigger source for strategy runs that reach the execution engine without identifying how they were invoked. This provides the provenance tracking needed to diagnose the intermittent duplicate-execution defect where sessions sometimes produce two pricing runs approximately 52 seconds apart. The CanExecuteStrategy guard already disables the menu item and keyboard shortcut during a run, so any unattributed run is definitively not a UI click and can now be traced accurately.

Cloud sync is now more reliable on store machines, especially during long sync sessions, by preventing network connection issues that could interrupt the sync process.

Hoisted the group table lookup query above the grouping decision branch so the common path reuses the result instead of querying sys.tables twice. This saves a database roundtrip when store grouping is properly configured.

The schedule migration code was moved from BackgroundServiceTabViewModel into MainMMViewModel.BackgroundCoordination.cs and is now called from both interactive startup (MainMMViewModel.InitializeAsync) and headless service runs (HeadlessRunner). This eliminates duplicate code and ensures consistent migration behavior across all launch paths.

Before modifying the connection registry, a safety backup is written to DatabaseConnections.json.cleanup.bak, providing a recovery path if manual restoration is needed. The cleanup runs fire-and-forget on a background thread after successful startup validation and swallows all exceptions to ensure it never affects application startup or stability.

Removed duplicate Upgrade-SSMS.ps1 script from the root Scripts folder and consolidated all setup scripts under the `scripts` folder (lowercase) to maintain consistency with the repository structure. This cleanup ensures there's a single source of truth for all PowerShell installation scripts.

Added EngineEdition property to SQL Server version detection queries and telemetry. This allows the application to distinguish Azure SQL from on-premises installations and apply the correct version-support policies to each deployment type.

Main table reconciliation now uses a single metadata query against sys.dm_db_partition_stats instead of running individual COUNT(*) queries for each store table (60-120 COUNT(*) operations on multi-million-row tables for large Epicor sites). Falls back to COUNT(*) only when metadata is unavailable.

Replaced individual COUNT(*) queries for each store's main table with a single metadata query using SQL Server partition statistics. For large multi-store databases (especially Epicor sites), this eliminates 60–120 COUNT(*) operations on multi-million-row tables during startup, reducing the time spent checking which tables need rebuilding.

Previously, the managed index rebuild process ran twice in quick succession when both RebuildMainTables and CreateTopPanel steps were queued—once during table rebuild and again a few hundred milliseconds later during selection box build. The first pass is now skipped when CreateTopPanel is also scheduled, since BuildSelectionBoxesAsync performs the same rebuild as part of its comprehensive seed-clean-rebuild sequence. This reduces startup time by eliminating redundant index existence checks and CREATE statements.

Added complete test suite verifying the update-service interaction contract, including guards for: both apply paths stopping the service first, failed stops aborting the update, headless imports blocking swaps, restart sentinel being set only when needed, sentinel consumption, and service binary bundling in publish workflow. These source-level tests protect against silent runtime failures that would otherwise be undetectable until machines stop receiving updates.

Created ScheduleMigrationReachabilityTests with four test cases that verify the migration runs in both interactive and headless startup paths, does not remain in the Options tab, and never enables unattended repricing. These tests prevent silent regressions where stores could lose their overnight update schedules.

New unit tests verify that the migration runs on both interactive and headless startup paths, confirms the Options tab no longer maintains its own copy, and validates that the migration never enables unattended repricing (ExecuteStrategy remains false). These tests prevent regression of the critical migration behavior that keeps stores updating overnight.

Removed dead code (SqlServerService.RemoveDeletedDatabasesAsync and SyncDiscoveredInstancesAsync) whose unsafe semantics would have deleted remote server entries and lacked the careful reachability checks implemented in the new cleanup system.

The automatic high-impact index creation from DMV scans is now limited to once per day instead of running during every startup splash screen. Post-strategy-run index recommendations continue to execute normally, ensuring optimal indexes are still created when needed.

The connection registry cleanup process now runs once per week instead of on every application launch. The cleanup probes every SQL Server listed in the connection registry with a 3-second timeout, which caused noticeable delays on machines with stale VPN entries or unreachable servers. Since the registry only changes when connections are modified, weekly cleanup is sufficient.

Modified the Ace zone pricing update script to use an explicit column list instead of SELECT *, allowing SQL Server to use the covering index RSIX_AceZoneRecords_ZoneSku without expensive key lookups. This optimization contributed to the overall 5.7x speedup in zone pricing updates observed in testing.

Updated CLAUDE.md and mi9-data-pipeline.md to clarify the positional (not alias-based) mapping of Mi9 user fields, document the UserDatetime1 effective date field, and correct the LastPriceChange field description (populated by Ace enrichment, not available for raw POS data).

Introduced ActiveRowCounter helper class to ensure both the orphan detection gate and existing count-validation logic use identical SQL queries. This prevents drift between the two count methods, which would silently break the optimization's correctness guarantee.

The cleanup now drops obsolete tables in a curated FK-safe order (children before parents) rather than sorting alphabetically, which previously caused SQL error 3726 by attempting to drop StrategyResultSnapshot before its child StrategyResultSnapshotDetail.

Connection registry cleanup (which probes every server in the connection list with a 3-second timeout per server) now runs weekly instead of on every launch, using a file-based timestamp gate. Reduces startup overhead for stores with multiple or stale server entries.

The DMV scan that identifies missing high-impact indexes now runs once per day instead of on every selection panel build (every startup and rebuild). This expensive database scan and potential index creation work is deferred from the splash screen startup window to reduce launch time. Post-strategy index recommendations continue to run immediately after strategy execution.

Extracted index rebuild decision logic into a dedicated IndexMaintenancePolicy static class with comprehensive unit tests (IndexMaintenancePolicyTests.cs). Tests pin the 1,000-page minimum and 30% fragmentation threshold, verify boundary conditions, validate the candidate selection and ordering logic, and document the regression origin with real measurements from Aubuchon Mi9. Follows the static-core pattern established by ImportFolderCleanupPolicy.

DatabaseCleanupService now re-checks the cleanup policy immediately before each DROP TABLE operation, so even if a future refactor passes in the wrong list, no table is destroyed.

Heavy background operations like SKU exception description validation and automatic strategy backups now run sequentially in a delayed chain (starting 30 seconds after startup) instead of firing simultaneously during the splash screen. This moves resource-intensive work out of the critical startup path and prevents multiple operations from competing for database resources.

SKU exception description validation and automatic strategy backup now run sequentially 30 seconds after the main window appears, rather than firing simultaneously during startup. This prevents multiple heavy database and cloud storage operations from competing during the busiest part of application launch.

A new "Guided SQL Server Setup" button on the Database Setup screen walks you through installing or upgrading SQL Server—you no longer need to run PowerShell scripts manually.

Use Tools > SQL Server Setup to install or upgrade SQL Server through a step-by-step wizard that automatically detects what's on your computer and recommends the right action. You'll see live progress as the installation runs and be notified if a restart is needed.

After installing a new SQL Server instance, you can now use "Migrate Database" (from the Tools menu or the success screen button) to move your Margin Master data onto it. The tool automatically backs up your database, moves it to the new instance, and optionally cleans up the old copy.

After installing a new SQL Server instance, you can use the "Migrate Database" option to move your Margin Master data from an old instance to the new one. The tool shows only your Margin Master databases, handles the technical details automatically, and keeps a backup file for safety.

You can now safely remove old Margin Master databases from Tools > Delete Database in the SQL Server Setup screen. The tool automatically backs up the database before deleting it and requires you to type the database name to confirm—the active database cannot be deleted from here.

IT staff can now safely remove old Margin Master databases through the SQL Server Setup window. The tool prevents accidental deletion by requiring you to type the database name exactly, won't let you delete the active database, and creates a backup first (enabled by default).

The background service now reports its health to the cloud automatically, making it easier for support to diagnose scheduling issues without needing your log files.

The background service now checks in with the Manager every hour (adjustable by the server), reporting its version, enabled state, job schedules, and last run results. This solves the "silent failure" problem where a stopped, crashed, or misconfigured service is indistinguishable from one that simply has no work scheduled. On startup, the service checks in immediately so new installs and restarts are visible right away. The heartbeat continues even during long-running imports so the service never appears dead.

Overnight data updates are now faster because POS and vendor data are imported together in one process instead of two separate runs.

Once you've moved all databases off an old SQL Server instance, you can remove that empty instance directly from the "SQL Server Instances" list using the "Remove..." button. The system prevents removing any instance that still has databases or wasn't originally installed by Margin Master.

After moving all your databases off an old SQL Server instance, you can now remove that empty instance directly from the SQL Server Setup window to free up disk space and simplify your setup.

If support needs to troubleshoot an issue, they can now request your diagnostic logs remotely instead of asking you to find and email files from your computer.

Support can now send time-limited commands to a specific store's background service through the Manager. The service polls for commands during each heartbeat, executes them, and reports results back on the next check-in. Commands are an allow-list of known operations the service already implements—anything unrecognized is rejected as unsupported rather than attempted. This channel is designed to never disrupt scheduled operations; all failures are logged and swallowed.

You can now schedule your pricing strategy to run automatically after the overnight data update, so future prices are ready each morning without manual intervention.

You can now view all SQL Server instances on your computer from the Tools menu, including which one Margin Master uses.

When you contact support about background service issues, they can now retrieve diagnostic logs remotely without needing to ask you to find and send files.

The overnight data update can now automatically run your pricing strategy after importing data, so new prices are ready when you open the store.

Setup scripts are resolved through a three-tier fallback (Azure blob → local cache → embedded resource) with parameter compatibility checking. If a cached or downloaded script is older than the app build and missing required parameters like -LogFile or -NonInteractive, the system automatically falls back to the embedded version to prevent silent parameter-binding failures.

The Tools menu now has shortcuts to re-scan your computer, copy diagnostic info for support, and open the setup log folder.

You can now view all SQL Server instances on the computer via Tools > SQL Server Instances to see which ones belong to Margin Master and which belong to other applications.

The "Checking this computer" step is now much faster, especially on machines with multiple SQL Server instances or many databases.

If a SQL Server instance is stopped, you can now start it directly from the instance list without manually using Windows Services.

If you see a stopped SQL Server instance, you can now click "Start Instance" to start it and verify whether it's being used by Margin Master.

When a SQL Server instance is successfully removed, the progress window now closes automatically and displays a clear confirmation message before returning to the instances list. This provides clearer feedback that the operation completed. Failed removals continue to keep the log window open for troubleshooting.

When migrating a database to another SQL Server, you no longer need to restart Margin Master. The app reconnects to the moved database instantly and continues working.

When moving a database, Margin Master will now automatically connect to it when the move completes.

If you run database installation or SSMS setup scripts and then report a problem the same day, those installation logs are now automatically included with your support ticket to help diagnose setup issues faster.

If you install or upgrade SQL Server or SQL Server Management Studio and then report a problem the same day, the installation logs will automatically be included with your support ticket to help our team diagnose the issue faster.

Overnight data updates now complete faster because the system rebuilds your pricing data once instead of twice.

If you installed the background service before this update, Margin Master will automatically upgrade its permissions the next time the app starts (one-time elevation prompt) so future uninstalls work correctly.

The startup self-heal that ensures the background service has proper permissions now checks for all three required rights: start (RP), stop (WP), and delete (SD). Services installed before this change had only start/stop and will be upgraded automatically. Added ApplicationSettingKey.BackgroundServiceFullGrantOk to track the upgraded grant; the old BackgroundServiceStartStopGrantOk key is superseded but retained for backward compatibility.

New SQL Server installations will use the instance name "MARGINMASTER" to avoid conflicts with other applications that may use "SQLEXPRESS."

The detection service queries each installed SQL Server instance to determine ownership by checking for Margin Master database signatures. Instances with at least one Margin Master database and no foreign databases are classified as "MarginMaster-owned" and eligible for in-place upgrade. All others are treated as foreign and never modified. Offline instances are safely classified as unknown/foreign to prevent accidental modification.

The SQL Server installer no longer shows extra console windows popping up during installation.

After migration completes, the message now clearly tells you whether Margin Master will connect to the migrated database when you restart.

The System Diagnostics screen now displays "Azure SQL" or "Azure SQL MI" for the database version label when connected to Azure-hosted databases, instead of showing an incorrect SQL Server year version.

License check-ins now include LAUNCHSOURCE (Desktop, Service, Manual, or Restore) and LAUNCHJOB (Vendor, Pos, Updates) fields. This allows the server to separate actual store usage from scheduled overnight imports and updates, providing accurate usage metrics in the fleet dashboard. The context is set at startup in App.OnStartup before any API calls can occur.

You now pick which days of the week scheduled jobs run (Monday, Tuesday, etc.) and what time they run at, making it easier to plan around your store's schedule.

Added source-level contract tests that verify the update process correctly stops the background service before swapping files, aborts if the stop fails, only restarts the service if it was actually running, checks for blocking processes, and ensures the service binary is included in published builds. These guards prevent silent update failures that would otherwise be invisible at runtime.

The setup wizard now accurately identifies which SQL Server instances belong to Margin Master, ensuring other applications' databases are never touched.

The planner automatically decides between in-place upgrade (when a single, older, Margin Master–owned Express instance exists alone on the machine) and side-by-side fresh install (when foreign instances exist, multiple instances exist, or the MM instance is non-Express). This prevents the scripts from attempting upgrades in unsupported scenarios and ensures clean installations when needed.

Enhanced SqlRestoreService to surface SQL Server's "percent processed" InfoMessage events as live progress updates during restore operations, and to explicitly set restored databases to MULTI_USER mode with a readiness wait loop (up to 30 seconds) to ensure the database is immediately usable after restore completes. Fixed a bug in SqlExpressMigrationService where restored databases were incorrectly named after the timestamped backup filename instead of the intended database name due to a missing RenameTo option.

Database restore operations now show real-time progress percentages and won't finish until the database is fully ready for use.

Enhanced GetStoreSettingsAsync to read ApplicationSettings first as the source of truth, then gap-fill from GlobalFileConfig only when ApplicationSettings values are blank. Previously, the method only read GlobalFileConfig (which it deletes on every startup), causing 109 of 134 surveyed databases to resolve a blank vendor and drop all Ace/Do it Best entities from the data model. Disagreements between the two sources are now logged as warnings, with ApplicationSettings winning and the legacy row removed.

Scheduled jobs are now configured by picking days of the week and a time, making it easier to set up overnight automation that matches your store's routine.

Install-SQLExpress.ps1 and Upgrade-SQLExpress.ps1 gain new parameters: -LogFile (starts a transcript for live tailing), -NonInteractive (auto-answers confirmation prompts per safe defaults), -ApplySectorWorkaround (consents to the 4K sector alignment fix), and -ReuseExistingBackups (upgrade only, skips re-backup if backups already exist). Scripts now report results via [MM-RESULT] markers that the app parses to auto-select the newly installed instance. Exit code contract: 0 = success, 3010 = reboot required, 20 = sector workaround consent needed.

Updated Uninstall-SQLServer.ps1 to support fully automated operation for the guided setup window, adding parameters for -InstanceNames (bypassing the interactive menu), -AllowEmptyRemoval (permitting removal of instances with zero databases), -LogFile (transcript for real-time tailing), and -NonInteractive (suppressing all console prompts). In non-interactive mode, safe prompts auto-answer Yes while risky prompts (continue without backup, continue after failed backup) answer No and exit with code 1. Child processes (setup.exe) now run with hidden windows and emit transcript heartbeat messages every 20 seconds during long silent phases. Exit codes standardized to 0 (success), 3010 (reboot required), or 1 (failure or ownership guard rejection).

The Uninstall-SQLServer.ps1 PowerShell script now accepts -NonInteractive, -InstanceNames, -AllowEmptyRemoval, and -LogFile parameters for automated removal workflows. In non-interactive mode safe prompts auto-answer Yes while risky prompts (continue without backup, continue after failed backup) answer No and exit with code 1. Long-running child processes (setup.exe uninstaller) now emit heartbeat messages every 20 seconds so transcript readers can distinguish active progress from hangs.

After a database deletion completes, the SQL Server Setup window automatically re-scans all instances to update their ownership classifications, such as marking an instance as "Empty" if the last Margin Master database was removed.

After moving a database, the server that received it is automatically selected so you can connect right away.

The service normally checks in once per hour, but the server can request faster polling (down to 30 seconds) while commands are outstanding. This makes remote support requests feel immediate without maintaining persistent connections or requiring inbound firewall rules. The minimum interval is enforced client-side to prevent server bugs from creating request loops.

Added an IsDestructivePhase flag to the BackgroundJobStatus table to distinguish between safe ingest operations (writing vendor/POS tables) and destructive rebuilds (dropping and recreating main tables and selection lists). This allows startup, the background service, and monitoring tools to make safe decisions about when to wait versus when to proceed. The flag is set during main table and selection list rebuilds and cleared during ingest and upon job completion.

The server list now automatically finds your SQL Server instance even if it has a custom name like MARGINMASTER.

The elevated script runner tails the PowerShell transcript in real time using a FileSystemWatcher, marshaling log updates through the WPF dispatcher so users see progress immediately. Previously, script output was only visible after completion.

Detection, plan review, execution, and result phases are now strictly mutually exclusive via the ShowExecution binding. The execution layout (step list + dark console panel) stays hidden during detection to prevent visual artifacts.

Store number comparisons throughout identity validation and renumbering detection now use a single normalization method (StoreIdentityRepairPolicy.Normalize) that preserves leading zeros only when the entire value would otherwise collapse to empty string. This prevents false mismatches when the licensing server returns store numbers with different zero-padding than what's stored locally.

Added migration support for contact phone numbers, which were previously never read from GlobalFileConfig and therefore remained stranded there permanently while email and contact name had migrated to ApplicationSettings. Phone numbers are now reconciled along with other store information on startup.

InitializeNewMarginMasterDatabaseAsync now writes store number, vendor type, and POS system to ApplicationSettings instead of GlobalFileConfig during database creation. This ensures newly created databases have their identity in the correct location from the start, matching where the running application reads it.

Extended BackgroundSettingsStore to read application settings by their raw property names (StoreNumber, RetailerSoftVendor, PCGUID) so the service can gather the identity information needed for check-ins, since those values are persisted by the WPF app under non-enum keys.

The run history now clearly shows when the scheduled data update changed your prices, making it easier to track overnight pricing changes.

When a SQL setup script exits with code 20 (sector workaround needed for older installers), the wizard displays an inline decision prompt explaining the issue and allows the user to consent or decline, then re-runs the script with -ApplySectorWorkaround if approved. This replaces the previous Read-Host prompts that couldn't be used in hidden/elevated scripts.

The credential merge operation in DatabaseSetupViewModel now writes reconciled store identity to ApplicationSettings instead of GlobalFileConfig. Previously it updated About and GlobalFileConfig but never ApplicationSettings, which allowed the two copies to drift apart over time.

After a successful SQL installation or upgrade, the Database Setup window automatically refreshes the server list and selects the newly installed/upgraded instance, allowing users to proceed directly to database creation or restore without manual server selection.

The install script now supports -LogFile for transcript routing, -NonInteractive to suppress Read-Host prompts (required for hidden execution), -InstanceName override (defaults to MARGINMASTER), and improved sector workaround handling with exit code 20 for consent requests.

The upgrade script now accepts -ReuseExistingBackups to skip fresh backup creation when acceptable pre-upgrade backups already exist, -LogFile, and -NonInteractive for wizard integration. Result marker lines ([MM-RESULT] Instance=... Server=...) allow the wizard to extract the upgraded instance details programmatically.

When you uninstall Margin Master from Windows Apps & features, the background Windows service is now properly removed instead of being left behind on your computer.

When you uninstall Margin Master from Windows settings, the background service is now removed automatically. Previously, the service would remain on your computer after uninstall.

Fixed a PowerShell array-wrapping bug in the SQL Express installer's ownership-check logic that caused crashes on systems with many databases. On instances with 170+ databases, the bug generated "identifier too long" SQL errors by concatenating all database names together. On instances with no databases, it threw PropertyNotFoundStrict exceptions that failed the "Remove Empty Instance" step during discovery. The fix corrects six call sites across Install, Upgrade, and Uninstall scripts. Since failures occurred during the discovery phase, no data was ever modified.

Manually adding SKUs to vendor catalogs will now work correctly without silent failures.

SSMS and .NET Runtime installation will now work reliably even when your computer is offline or the cloud backup is temporarily unavailable.

If your store uses Azure SQL Database or Azure SQL Managed Instance for hosting, you will no longer see warnings about running an unsupported or outdated version of SQL Server.

If your store information ever appeared to change to a different company's store number after a network interruption, this issue is now fixed. Your store identity will remain stable even during connectivity problems.

Fixed a critical issue where store identity (store number, vendor, RSC code, POS system) was stored in both GlobalFileConfig and ApplicationSettings but only partially synchronized between them. A survey of 134 customer databases found all still carrying duplicate POSTYPE entries, 62 carrying duplicate STORENAME, and four stores with actively conflicting identities (including one Ace store incorrectly configured as Do it Best, causing it to use the wrong database tables). ApplicationSettings is now the single authoritative source, with automatic reconciliation on startup that preserves data and logs warnings when conflicts are detected.

If the licensing service accidentally returns information for a different store, Margin Master will now reject it and keep your existing license instead of changing your store identity.

Previously, scheduled imports that completed in under 30 seconds would exit before their license check-in POST reached the server, causing them to not appear in the fleet dashboard. The headless runner now waits up to 10 seconds for the check-in to complete, ensuring all background runs are properly recorded regardless of how fast they complete. Found when Great Lakes Ace and Breed & Company showed "1 launch today" despite having five scheduled service runs and zero interactive launches.

Updates will no longer fail silently when you have Margin Master open. The background service now waits until you close the app, and your open session will install updates automatically.

The background service's silent self-update would previously attempt to swap application files while a user had Margin Master open. Because Velopack cannot replace folders used by a running process, updates would silently fail and the machine would remain on the old version indefinitely. The service now uses a machine-wide presence marker to detect interactive sessions and defers updates until the app is closed, allowing the app's own hourly update check to handle installations while in use.

When the background service launches a headless import (MarginMaster.exe --data-update), that import process holds the installation directory open for its entire duration. Previously, if an update was ready to apply during an import, it would stop the service but proceed with the file swap anyway. Because the headless import child process continued running even after the service stopped, the swap would fail silently—reporting success but actually making no changes—leaving the machine stuck on the old version indefinitely. The update system now detects when another Margin Master process is running from the install folder and defers the update until the next launch after the import completes.

SQL Server's uninstaller sometimes leaves the SQL Server Agent service registration behind after removing an instance (observed on SQL 2025 Standard). The removal script now automatically deletes these orphaned Agent service registrations after verifying the engine service has been successfully removed.

The uninstall script now detects and removes orphaned SQL Server Agent service registrations that SQL setup sometimes leaves behind after uninstalling an instance (observed with SQL 2025 Standard). The cleanup only runs when the engine service is confirmed removed, ensuring safe deletion.

The list of available databases now updates automatically after moving or deleting a database.

Normalized file paths for setup scripts that were tracked under a capital-S `Scripts/` folder while other scripts used lowercase `scripts/`. On Windows these appeared identical but caused the cloud upload process to miss certain files. All scripts are now consolidated under the lowercase `scripts/` directory.

If your store was accidentally configured with the wrong vendor's store number, the automatic repair system will no longer incorrectly overwrite your actual store information across multiple database tables.

Added fallback logic to recover store identity from GlobalFileConfig when ApplicationSettings is blank, rather than leaving the store permanently unconfigured. Previously, if ApplicationSettings lacked a store number, the application could never recover it and would only display the Store Configuration window. The reconciliation now seeds ApplicationSettings from the legacy row when needed, then removes the duplicate to prevent future conflicts.

Fixed an issue where fast scheduled imports (under ~30 seconds) would exit before their license check-in completed, causing these runs to not appear in the fleet dashboard at all. The app now waits up to 10 seconds for the check-in to complete before shutting down. Longer imports were already counted because they naturally took long enough for the background post to finish.

If you launch Margin Master while a background import is rebuilding data, the app will now wait and show you the rebuild progress instead of opening with blank or incomplete pricing tables.

If you open Margin Master while a background update is rebuilding data, you'll see a progress message on the startup screen instead of an empty or partially-loaded grid.

If removing a SQL Server instance fails, the instance will be automatically restarted so it remains usable and visible in the list.

If removing a SQL Server instance fails, the service will automatically restart so your system is left as it was before the attempt.

If you try to delete the database Margin Master is currently using, you'll now see a clear message explaining that you need to switch to another database first.

Database migration during initial setup now completes smoothly without freezing.

Fixed GetPCGUID to read the persisted ComputerSettings.PCGUID value instead of generating a fresh random GUID on every license request when the MM_PCGUID machine environment variable was absent (which it always was). This was causing every license validation to register as a new PC against the store's licensed computer count rather than recognizing returning installations.

Stores running automatic background updates will no longer waste resources checking for updates that don't exist. The service now correctly tracks which version is installed.

The recorded installed version was only written during interactive app startups. On machines where the background service handled all updates and no user opened the app, the recorded version remained frozen at the last manually-opened build. This caused the service's update pre-check to detect a "newer" version every cycle and launch the full app only to be told it was already current. Headless runs now update the installed version marker, eliminating unnecessary update checks.

Refined the logic that records whether the background service should be restarted after an update. The sentinel is now set only when a service that was actively running is stopped for the update, preventing updates from quietly enabling a service the user intentionally left disabled.

The SDDL rights parser now splits the rights string into two-character codes before checking for "SD" (delete), preventing false positives when the substring "SD" spans code boundaries (e.g., "RSDT" is RS + DT, not R + SD + T). Updated unit tests confirm the parser correctly rejects legacy start/stop-only grants and malformed rights strings.

Issue submission documentation now describes the three-bucket auto-attachment system: application logs, strategy execution logs, and same-day installation script logs. Search keywords updated to include "strategy execution logs", "installation script logs", and "script transcript".

Updated the INSERT statement for manual catalog items to explicitly provide GETDATE() for CreateDate as a defensive measure, ensuring the operation succeeds even if the DEFAULT constraint is somehow missing.

If certain features or data weren't working correctly for Ace Hardware or Do it Best stores, this fix restores proper vendor-specific functionality by ensuring your vendor type is correctly identified.

The automatic store renumbering feature (MM-1395) now verifies the licensed vendor matches the database's vendor before re-pointing a store to a new number. A renumbering only happens within the same vendor family. This prevents a license response for a different company's store from stamping their identity across StoreManagerInfo, GlobalFileConfig, and About tables, which would destroy all copies of the real store's identity. Ace Hardware and Emery Jensen are treated as one vendor family since EJ stores are carried as Ace in the vendor tables.

Fixed SqlExpressMigrationService to pass RenameTo: dbName in RestoreOptions. Previously the restored database inherited the timestamped backup file's name (e.g., "MyDb_PreMigration_20260816_143022") causing subsequent verification and compatibility-level steps that connected using the original dbName to fail.

The IsDue calculation now walks back 0..6 days instead of 0..7, preventing a never-run job from treating "last week's occurrence" as overdue and firing immediately when enabled. A dedicated test pins this behavior, ensuring that enabling a 02:00 schedule at midday does not trigger an import in the middle of a working day.

Fixed DatabaseService3.IsSqlServerInstalledAsync and SqlServerScannerService to detect any MSSQL$ service prefix (covering MARGINMASTER, SQLEXPRESS, and custom names) instead of only checking for MSSQLSERVER and MSSQL$SQLEXPRESS. This prevented machines with only a MARGINMASTER instance from being recognized as having SQL Server installed.

Fixed DatabaseUpdateService.RSCCode property and CleanMMVendorData method to read from ApplicationSettings.RSC instead of the legacy GlobalFileConfig row that GetStoreSettingsAsync deletes on every startup. Previously, reading the deleted row meant setting the RSC here had no effect, and the MMVendorData cleanup was being skipped on migrated databases.

License validation now reports the SQL Server engine edition (SQL_ENGINEEDITION) to fleet telemetry, allowing Manager to distinguish between Azure SQL Database, Azure SQL Managed Instance, and on-premises editions for support and monitoring purposes.

The setup window now shows what it's checking in real-time and runs much faster on computers with many databases.

During SQL Server installation or upgrade, the setup window now shows how long each step has been running and reassures you that long silent phases are normal and still progressing.

When installing or upgrading SQL Server, the setup window now shows how long each step has been running and displays "still working" messages during long quiet periods so you know it hasn't frozen.

After successfully removing a SQL Server instance, you'll now see a confirmation message and return to the instances list automatically, making it clearer that the removal completed.

A new checkbox lets you tell Margin Master to use the migrated database automatically when you restart the application, even if you're currently working with a different database.

The setup wizard now clearly explains why a new SQL Server instance is being installed instead of upgrading your existing one.

The setup window shows a proper busy indicator while checking your computer and no longer appears frozen during detection.

Installer windows no longer flash on screen during SQL Server setup, making the installation process cleaner and less distracting.

You can now refresh the SQL Server instance list using the Refresh button at the bottom of the window instead of closing and reopening it.

You can now click "Refresh" to update the list of SQL Server instances after making changes to your system.

The Migrate Database window now clearly indicates that the connection switch happens immediately when the move completes.

Both the full Submit Issue wizard and Quick Issue Submit dialog now display "Collecting installation script logs..." and "Uploading installation script logs..." status messages during the attachment process, providing visibility into this new automatic step.

Added the SQL Express vs. Full License guide to the documentation index with comprehensive search keywords covering common symptom searches like "slow performance," "50 GB limit," "database size cap," and "when to upgrade SQL Server," making it discoverable through the in-app help system.

The "What we found" section is easier to read, with SQL Server and Management Studio status shown on separate labeled lines.

After a successful instance removal, users now see a confirmation dialog stating "Instance 'X' was successfully removed" and are returned to the refreshed instances list, making the outcome of the operation immediately clear.

The Delete Database dialog implements progressive disclosure with instance selection, database dropdown (showing only verified Margin Master databases), backup checkbox (default on), and a text field requiring exact database name entry. Visual warnings appear if the selected database is currently active. A red header and warning text emphasize the destructive nature of the operation.

The delete tool walks you through choosing a server and database, asks if you want a backup first, and requires typing the database name exactly before the Delete button activates.

Both the full Submit Issue wizard and Quick Issue Submit dialogs now display "Collecting installation script logs..." and "Uploading installation script logs..." status messages when script transcripts are found and attached. This upload occurs after the standard application log attachment and before database backup/additional file uploads.

After moving a database, the migration windows close automatically and Margin Master loads your data from the new location right away.

The Background Service settings screen is simpler and shows exactly what your overnight update will do and when it will run next.

Status messages throughout the setup process are clearer and easier to understand.

After installing a new SQL Server instance, the success screen now shows a "Migrate a Database..." button to help you immediately move your data onto the new instance.

After the setup finishes installing a new SQL Server instance, a "Migrate a Database" button appears to guide you through moving your data onto the new instance.

If your hard drive needs a special compatibility fix during SQL installation, the setup window will ask for your permission before applying it—no hidden prompts.

The overnight automation settings are now simpler to configure, with clear day-of-week checkboxes and plain-English descriptions of when jobs will run.

You can launch the guided SQL Server setup from multiple places: the Database Setup screen, the File menu under Utilities, or the Support Scripts window.

Added "SQL Server Setup" to the Tools > Support menu in the main window and as a button in the Database Setup window's SQL Server and SSMS sections, providing multiple entry points to the guided setup flow.

The MigrationBasedSchemaCreator now emits DEFAULT constraints (both SQL expressions and literal values) when creating tables, ensuring NOT NULL columns like CreateDate have working defaults. Includes culture-invariant formatting for bool, string, DateTime, and enum defaults.

Added a startup migration that detects and repairs ManualCatalogItems tables created without the CreateDate DEFAULT constraint, preventing insert failures in databases created prior to this fix.

Fixed four code paths that were writing store identity to GlobalFileConfig instead of ApplicationSettings: database setup, database creation, RSC code updates, and POS system changes. These writes were being silently discarded on the next startup when the per-startup cleanup removed the GlobalFileConfig entries, causing settings to appear saved but then vanish. All identity writes now go to ApplicationSettings where the running application reads them.

Database compatibility level logic now recognizes Azure SQL can use level 160 (SQL 2022 feature set) regardless of its reported product version, ensuring optimal query performance and feature availability.

Added a versioned migration that removes residual store identity entries from GlobalFileConfig once ApplicationSettings contains valid data. The cleanup backs up removed data to GlobalFileConfigBackup first and includes safety checks: it refuses to run when ApplicationSettings has no store number (preventing deletion of the last surviving copy of a store's identity), and only marks itself complete on success so failed deletions retry on next startup rather than leaving orphaned data.

Added `IsDestructivePhase` flag to the `BackgroundJobStatus` table to distinguish between safe ingest phases (which write vendor/POS tables the grid never binds to) and destructive rebuild phases (which drop and recreate main tables and selection lists). The distinction matters because ingest can safely run underneath an open app and can take ten minutes—making users wait through that would be its own bug. The flag is set by actual phase transitions rather than matching phase text, so renaming a step cannot break the data-corruption guard. Includes idempotent ALTER for stores that already have the table.

Added ApplicationSettingKey entries for the Data Update job configuration (enabled, days, time, last run, include POS, include vendor, execute strategy) and for the day-based schedules for the updates job. Added BackgroundScheduleMigrated flag to track when old per-job schedules have been converted to the new unified model. Vendor and POS keep their enum values so historical run-history rows still render, but nothing schedules them anymore.

Consolidated store identity management so ApplicationSettings is the authoritative source for store number, vendor type, RSC code, POS system, and store name. License responses no longer overwrite these values—they only confirm them or fail validation. Previously, these values were written to three locations (ApplicationSettings, GlobalFileConfig, and About table) with no reconciliation, causing stores to disagree with themselves. A survey of 134 databases found all carried both copies, with four actively disagreeing (including one with mismatched vendors causing incorrect entity resolution).

Created LaunchContext static class to hold AppLaunchSource and background job name, set once during startup and readable by license validation. Uses the same ambient pattern as MarginMasterVersionSettings to provide launch attribution without requiring dependency injection in low-level services.

The post-processing queue now supports deferred draining, allowing both POS and vendor imports to queue their rebuild steps before draining once. This is the core architectural change that enables the unified Data Update job: both ingests contribute to the same queue, which deduplicates and drains in a fixed order, producing exactly the union of both rebuilds in a single pass. The headless runner suppresses post-processing drains during import steps and explicitly drains once after both sources have contributed.

Introduces SqlSetupPlanner, a pure-logic component (17 unit tests in SqlSetupPlannerTests) that maps detected SQL environments to ordered script steps. The planner enforces product rules: upgrade only single MM-owned Express instances in place; never touch foreign instances; always install side-by-side when multi-instance or non-Express; SQL steps before SSMS steps. Behavior is pinned by tests to prevent regression.

Created new documentation explaining SQL Server 2025 Express limitations (50 GB database cap, 4 cores, 1.4 GB buffer pool, no SQL Agent) versus full licensed editions. Includes a comparison table, guidance on when stores have outgrown Express based on symptoms like slow performance during peak hours or multi-store deployments, and clarifies that the 2025 edition's increased size cap (up from 10 GB) doesn't change compute restrictions. Indexed for support staff and end users researching database performance issues or upgrade decisions.

Updated DevExpress.Wpf and DevExpress.Document.Processor from version 26.1.3 to 26.1.4. This maintenance update includes the latest bug fixes and stability improvements from DevExpress for the UI grid controls, dialogs, and document processing components used throughout Margin Master.

Updated nsoftware.IPWorks to build 9722 and nsoftware.IPWorksSSH to build 9716, with corresponding updates to runtime license stamps in licenses.licx. These components handle FTP and SFTP vendor file downloads.

Behind-the-scenes improvement that helps RetailerSoft better understand how stores are using Margin Master versus how often automated background jobs are running.

Removed double array-wrapping around Invoke-SqlQuery results that caused incorrect iteration behavior under Windows PowerShell 5.1 strict mode. Plain assignment now correctly binds the inner row array across all zero, single, and multi-row result scenarios.

The delete operation performs dual fingerprint verification—once when populating the database list and again immediately before dropping—to ensure only genuine Margin Master databases can be deleted. The service counts core Margin Master tables (Store, Item, PricingRule, etc.) and requires a minimum match threshold before allowing deletion.

Implemented database verification logic that checks for the presence of core Margin Master tables (Item, Store, Vendor, etc.) before allowing deletion. Only databases that match the Margin Master signature with a minimum number of core tables can be selected for deletion, preventing accidental deletion of unrelated databases.

New ScriptLogCollector service consolidates script transcript discovery across three different app locations (%TEMP%\MarginMaster\InstallationScripts\Logs, %TEMP%\MarginMaster\ScriptLog_*.txt, and C:\ProgramData\RetailerSoft\MarginMaster\DiagnosticTool\Logs\Scripts). Only logs written on the requested date are collected, ensuring relevance to same-day issues. Handles locked files gracefully by reading with FileShare.ReadWrite and deduplicating entry names when multiple sources contain identically-named files.

Added IPWorksLicenseBuildTests to fail the build if nsoftware package versions are bumped beyond what the runtime licenses cover. Previously, this mismatch would only surface as connection failures at runtime; now it's caught during development. The drift check now runs in all configurations, not just DEBUG builds, and reports failures during startup validation before any vendor sync attempts.

The Velopack OnBeforeUninstallFastCallback hook now logs sc.exe stop and delete exit codes to UninstallHook.log in the ProgramData log folder, which survives uninstall. This provides a forensic trail for diagnosing service-removal failures and replaces silent failures that previously hid orphaned services.

The Velopack uninstall hook now writes detailed outcomes (sc.exe exit codes, access denied errors, success/failure) to UninstallHook.log in the ProgramData log folder. This file survives uninstall and provides a forensic trail for troubleshooting orphaned services, since Serilog is not yet configured inside uninstall hooks.

Added a new PowerShell helper function that starts child processes with proper window hiding in non-interactive mode and polls for completion while writing periodic heartbeat messages to the transcript. This ensures long-running silent phases (media extraction, VC++ install, SQL setup) remain visible to both the UI (via transcript) and the user (via status bar timer).

The Install-SQLExpress.ps1 and Upgrade-SQLExpress.ps1 scripts now include an Invoke-ChildProcess function that writes heartbeat lines to the transcript every 20 seconds during long child processes, ensuring the UI transcript reader can distinguish between silent execution and hung processes.

Support documentation updated to describe the three script log sources, same-day collection logic, shared-access file reading for locked transcripts, and best-effort upload behavior.

Created SetupScriptEmbeddedResourceTests that verify all setup scripts referenced by the installer (Upgrade-SSMS.ps1, Install-SQLExpress.ps1, Install-DotNetRuntime.ps1, etc.) are properly embedded with the exact resource names the resolver expects. This prevents the embed glob from silently breaking in future builds due to path changes or git case-folding issues.

Updated Entity Framework Core from 10.0.10 to 10.0.11, Microsoft.Extensions.* packages from 10.0.10 to 10.0.11, MySqlConnector from 2.6.1 to 2.6.2, and various other supporting libraries (NuGet.*, Sep CSV parser, ClosedXML, xunit test runner). These updates include security patches and bug fixes from upstream packages.

LaunchAttributionTests pins the command-line-to-attribution mapping and validates that enum member names match what the server accepts. This prevents silent reclassification if either side changes - job names travel as text so new background jobs require no database migration, but renaming would split history into two separate entries on the dashboard.

Added 115 lines of tests to verify that each launch scenario (desktop, scheduled service, manual "Run Now", and silent updates) is correctly identified and reported. This ensures usage metrics remain accurate as new background job types are added and prevents scenarios where automated activity is miscounted as user engagement.

Implemented a command dispatcher with a fixed allow-list of supported operations. Commands name operations the service already implements and never carry executable payloads. Authentication uses store and vendor numbers rather than sensitive credentials, so the system is designed with limited blast radius. Unrecognized commands are reported as unsupported (not failed) so services running older builds are distinguished from broken ones. Commands expire automatically and all execution happens asynchronously without blocking scheduled jobs.

When backup is enabled (the default), the service creates a timestamped backup file (e.g., MyStore_PreDelete_20260816_143022.bak) before deletion. If the backup fails for any reason, the deletion is aborted and the database remains untouched. The backup file is retained even after successful deletion to allow recovery if needed.

Deleted stale root-level Scripts/Upgrade-SSMS.ps1 file. All resolver calls now use the correct version located in the SqlScripts/Powershell subdirectory.

Removed unused nsoftware package references from MarginMaster.DiagnosticTool. The tool wasn't using these components and was unnecessarily shipping licensed assemblies.

Created a command routing system that matches incoming command types to their handlers and enforces expiration times. The service authenticates to the Manager using store number and vendor ID to obtain short-lived bearer tokens (cached and auto-refreshed). Uses the same fallback URL list as the main app to handle Azure deployments and network issues gracefully.

Introduced a new `InteractiveSessionPresence` marker using a Global mutex that the background service (running in session 0) can see when an interactive user (in session 1) has the app open. The existing single-instance mutex was session-local and invisible across session boundaries. Includes full test coverage (62 new tests) and fail-safe behavior—if the marker cannot be created or checked due to permissions, it reports "nobody is there" and degrades to previous behavior rather than blocking unattended operations.

Existing per-job vendor and POS schedules are automatically migrated into the unified data update configuration once on first launch: all seven days are selected (preserving daily behavior), the earlier of the two configured times is used, and the ExecuteStrategy option is set to false unconditionally. The migration ensures no store begins scheduled repricing without explicit consent, even when upgrading from configurations that previously ran separate vendor and POS jobs.

Added explicit documentation that MySql.Data remains pinned at 6.10.9 as the legacy fallback driver behind the UseMySqlConnector toggle. This clarifies that it is not on the routine update path and will only be removed once migration to MySqlConnector is complete.

The service acquires and caches bearer tokens for API authentication using store number and vendor ID, refreshing them before expiration. Includes automatic fallback between primary and backup API endpoints, with preference for whichever worked last time to minimize calls on healthy systems.

Introduced InteractiveSessionPresence utility that uses a Global\ mutex to signal when an interactive Margin Master session is open. Unlike the existing single-instance mutex (which is session-local), this marker is visible to the background service running in session 0. The implementation gracefully degrades to local-only scope if SeCreateGlobalPrivilege is unavailable and fails to false (reports "not present") if the marker cannot be read, ensuring permission issues never block legitimate operations.

Extracts script resolution (blob download → local cache → embedded fallback) into SetupScriptResolver and elevated PowerShell execution with live log tailing into ElevatedScriptRunner, replacing duplicated logic in DatabaseSetupViewModel and ScriptProgressViewModel. Includes parameter-capability probing: if a cached/blob script predates required parameters like -LogFile, it is replaced by the embedded copy to prevent silent failures.

Added CleanUpStoreIdentityGlobalFileConfigAsync migration that removes SETTINGS/STOREINFORMATION rows from GlobalFileConfig once ApplicationSettings holds the store's identity. This cleanup runs after GetStoreSettingsAsync reconciles the values, ensuring no data loss. The cleanup version flag is excluded from settings transfer to prevent a transferred "already done" flag from suppressing cleanup on a database that still needs it.

Added BackgroundScheduleTests to verify day-of-week schedule evaluation, including edge cases like DST boundaries, never-run jobs, and daily schedules. Added DataUpdatePlannerTests to prove what a scheduled data update does given its configuration, including the critical safety case that a strategy-only configuration (no data sources) is refused to prevent unattended repricing.

The headless runner now accepts --data-update to run the full configured update in one process. The legacy --import-vendor and --import-pos flags are retained as support escape hatches for diagnostics, but the scheduler only invokes the unified command. Post-processing drain suppression allows both imports to queue steps into a single rebuild operation.

Adds new guided-setup support doc (marginmaster/support/sql-server-setup-window.md) with screenshots and troubleshooting steps, plus updates to install-sql-express.md and upgrade-sql-express.md documenting the new script parameters and exit codes. Index entries link the new content.

Added SqlSetupPlannerTests with 19 test scenarios covering all decision branches: clean machine, single old instance upgrade, multi-instance side-by-side install, foreign instance handling, offline instance classification, instance name collision fallback (MARGINMASTER → MARGINMASTER2 → MARGINMASTER3), SSMS ordering, and answer handling (ReuseExistingBackups switch).

The system now analyzes which departments are most sensitive to price changes based on your actual sales volume, helping identify where to be careful with price increases versus where you have more flexibility.

Added support for Do it Best Awareness Code "E" (Commodity), mapped to the 25-point bottom rung alongside "D" (Low Awareness). OneClick query now captures "E" separately and the sensitivity engine scores it as low-awareness volume eligible for margin improvement. This aligns with Do it Best's five-tier awareness system.

If no pricing tables are selected, One Click will now automatically analyze all available tables instead of showing blank results.

When Margin Master detects an old version at startup, the uninstall prompt will now appear properly on your screen instead of being hidden or causing an error.

Corrected a SQL alias mismatch in the sensitivity scoring engine that referenced "x.Code" instead of "codes.Code" for both Ace Hardware and Do-it-Best vendors. This bug could have caused sensitivity scores to be calculated incorrectly or fail to execute during margin analysis.

When you open the One Click dialog, you'll now see the correct item counts right away instead of all zeros.

When you open One Click Statistics, the numbers now show up right away instead of showing all zeros until you click a checkbox.

The Pricing Sensitivity Mix panel on OneClick now shows the correct labels for each sensitivity category—previously "Sensitive" and "Blind" were backwards for Ace stores.

Corrected a typo in the Print button command binding ("PrintClickComand" to "PrintClickCommand"). This was a latent bug as the button is currently disabled.

Strategy Comparison now shows which departments and classes are most price-sensitive, with higher scores meaning customers are more aware of price changes in those categories.

The dialog now calls PopulateCurrentStoreAsync during initialization to ensure statistics are visible immediately, since the checkbox toggle handlers only refresh data on change events, not on initial state.

Added comprehensive unit tests locking the sensitivity-score contract: shared 25-100 rung mappings for Ace and Do it Best, units-weighted scoring math, null-when-no-assigned-volume behavior (never zero), additive roll-ups enabling class-to-department aggregation, and Blind/Sensitive share calculations. Tests ensure code changes (like moving DIB "E" to the 25 rung) are intentional and verified.

Introduced ShowModalSafeAsync method to safely display modal dialogs from background startup tasks. This ensures the splash screen is verifiably closed and all dialogs are opened on the UI thread, preventing both threading violations and unreachable dialogs blocked by the splash screen.

Before running a strategy, you'll now be warned if any custom groups or SKU exceptions are set up incorrectly and won't price anything, with details about what needs to be fixed.

Long lists of excluded location codes can now be copied with one click instead of being typed manually from the screen.

When warned about incomplete exceptions, you can choose to save them anyway to finish the work later—the system will check again before actually running your pricing strategy.

If you open the screen and have groups with margin percentages in their names but no margin settings, the system will offer to fill in the missing margins automatically, making it easier to fix broken groups right away.

Saving and closing the SKU-Level Exceptions screen will work reliably, even if the system encounters internal messaging issues.

Both manager screens now run their validation checks after the save/discard prompt rather than before, ensuring the checks work on what's actually stored in the database. This prevents the confusing scenario where you discard unsaved changes but still get warnings about problems that no longer exist, or miss warnings about problems you just saved.

If you click Save and nothing happens, you'll now see a message explaining why—either there are no changes, or you need to click out of the box you just typed in.

When creating pricing strategy steps, the standard price levels (Retail, Level1, Level2) now always appear in the "compare to" dropdown, even if you're using a custom column view. Previously, these options could disappear if your view showed certain price columns, which caused pricing steps to stop working.

When you type a margin percentage into a custom group, it will now save properly instead of disappearing.

If you save a SKU exception without filling in all the pricing details (like choosing "Margin %" but not entering a percentage), you'll now see a warning telling you which SKUs won't be priced. You can still save the incomplete rule to finish later, but you'll know it won't work until completed.

If you close the Custom Groups screen with groups that have names like "25%Margin" but no actual margin set, Margin Master will now offer to set the margin for you based on the name. This prevents pricing rules from silently failing to apply.

The Manage Custom Groups screen will no longer crash when opening. If you have groups that need pricing repairs, you'll see the repair prompt after the window appears.

If you cancel a pricing run before it starts, the app will no longer ask if you want to run it "again" on your next attempt.

Existing pricing strategies that compare current price to standard levels like "Level1" now work correctly, even when those levels aren't visible in your current column view.

Custom groups and SKU exceptions will keep their configured price levels even if you can't see that price level in your current view settings.

If you try to close the SKU Exceptions screen with exceptions that won't actually price (missing margin, markup, or price level), Margin Master now shows you which SKUs have problems and lets you stay on the screen to fix them instead of silently failing later.

Custom pricing groups will now keep their cost basis setting (like Average Cost) when you make changes and save the group.

The Save button will work correctly even if a custom group uses a rounding scheme that's not available on your computer.

Error icons now correctly appear and disappear as you fix or break pricing groups, keeping the display accurate.

The prompt offering to fix custom groups with no price level now appears at a better time—after the window is visible but before user interaction begins. The prompt is displayed at application idle priority so the window paints fully first, and is protected against WPF's re-parenting behavior that could cause it to appear multiple times. A failure in the repair offer itself can no longer prevent the screen from opening.

Custom groups and SKU exceptions will remember the rounding scheme you chose for them instead of switching to the default rounding scheme.

When a pricing strategy error appears showing excluded location codes, click the new Copy button to copy all the details to your clipboard instead of manually typing them out.

When you see a Strategy Step Load Error, you can now click the Copy button to copy the entire error message, then paste it into an email or support ticket instead of manually typing it out.

When an error occurs during strategy execution, the Copy button now appears at the bottom right, just below the error message box, making it easier to understand that clicking it will copy the error details shown above.

When you see an error dialog during strategy execution, the Copy button now appears at the bottom right, next to the action choices and directly under the error message box, making it easier to understand what text will be copied.

Broken pricing groups now show a red error icon immediately when you open the screen, with a message explaining what's wrong. You don't need to open each group or wait until closing to find problems.

Created new MissingPriceLevelDetector helper class with 35 unit tests to analyze saved rule text and determine if a rule can produce a price. This logic is pure and reusable, working directly from the stored rule format rather than UI state, making it reliable for both save-time validation and pre-flight checking.

Moved obsolete update failure cleanup to run before classifying the current launch's update state, ensuring that machines which have already successfully updated don't carry stale failure markers that would incorrectly influence the current launch's error reporting level.

Stores that successfully update but take an extra app restart to complete the process will no longer show up as "update failed" on support dashboards.

The version gate check during startup and the update-from-database-setup-window path were leaving behind "pending update" markers when the update failed to apply, causing the next launch to incorrectly report a locked install directory for an update that was never attempted. Both paths now clear the pending marker and record the failure at the actual point of failure.

Added six new tests in UpdateHealthPolicyTests that replay real store occurrence sequences, including Store 12233's self-healing deferred updates and Store 12082's genuinely locked installation scenarios.