diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6da79e8..4f4f236 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -67,8 +67,8 @@ jobs:
shell: pwsh
run: |
$now = Get-Date
- $msi = "$($now.Year - 2000).$($now.Month).$($now.Day).$($now.ToString('HHmm'))"
- "msi=$msi" | Out-File -Append $env:GITHUB_OUTPUT
+ $full = $now.ToString('yyyy.MM.dd.HHmm')
+ "full=$full" | Out-File -Append $env:GITHUB_OUTPUT
- name: Build CLI (managedbootstrapinstall.exe)
run: >
@@ -98,7 +98,7 @@ jobs:
"--configuration", "Release",
"--verbosity", "minimal",
"-p:Platform=${{ matrix.arch }}",
- "-p:ProductVersion=${{ steps.version.outputs.msi }}",
+ "-p:FullVersion=${{ steps.version.outputs.full }}",
"-p:BinDir=$binDir",
"-p:AppDir=$appDir"
)
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 7017eb5..40b22ff 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -51,13 +51,7 @@ jobs:
run: |
$tag = "${{ github.ref_name }}"
$full = $tag -replace '^v',''
- if ($full -match '^(\d+)\.(\d+)\.(\d+)\.(\d+)$') {
- $msi = "$([int]$Matches[1] - 2000).$([int]$Matches[2]).$([int]$Matches[3]).$($Matches[4])"
- } else {
- $msi = $full
- }
"full=$full" | Out-File -Append $env:GITHUB_OUTPUT
- "msi=$msi" | Out-File -Append $env:GITHUB_OUTPUT
- name: Build CLI (managedbootstrapinstall.exe)
run: >
@@ -152,7 +146,7 @@ jobs:
"--configuration", "Release",
"--verbosity", "detailed",
"-p:Platform=${{ matrix.arch }}",
- "-p:ProductVersion=${{ steps.version.outputs.msi }}",
+ "-p:FullVersion=${{ steps.version.outputs.full }}",
"-p:BinDir=$binDir",
"-p:AppDir=$appDir"
)
diff --git a/Logger.cs b/Logger.cs
index 25ceb3d..14c8765 100644
--- a/Logger.cs
+++ b/Logger.cs
@@ -41,6 +41,7 @@ public static void Initialize(string logDirectory, string version = "Unknown", b
_verboseConsole = verboseConsole;
_silentMode = silentMode;
_sessionStartTime = DateTime.Now;
+ LogDirectory = logDirectory;
// Ensure log directory exists
if (!Directory.Exists(logDirectory))
@@ -449,6 +450,9 @@ public sealed record SessionOutcome(string Status, DateTime End, int Errors, int
/// Relabels the session with the mode the preflight chose.
public static void SetRunType(string runType) => _session?.SetRunType(runType);
+ /// The logs root this run's session directory sits under.
+ public static string? LogDirectory { get; private set; }
+
/// When this run's session started.
public static DateTime SessionStartTime => _sessionStartTime;
diff --git a/Program.cs b/Program.cs
index 2e9deb2..201ac4a 100644
--- a/Program.cs
+++ b/Program.cs
@@ -846,6 +846,10 @@ private static int SaveSettingsFromArgs(string[] args)
// Initialize status tracking
StatusManager.Initialize(manifestUrl, Version);
+
+ // Looked at before the preflight, which consumes it: the throttle only looks.
+ bool forced = File.Exists(BaselineThrottle.ForceFilePath);
+
RunReport.Start(Version);
Logger.Debug($"Initialized status tracking with RunId: {StatusManager.GetCurrentRunId()}");
@@ -928,6 +932,24 @@ private static int SaveSettingsFromArgs(string[] args)
bool baseline = decision == PreflightDecision.Baseline;
if (baseline)
{
+ // Applied only once the preflight has chosen baseline, so provisioning is
+ // never limited. The manifest and preflight are small; a throttled run
+ // downloads no item.
+ var throttle = BaselineThrottle.Evaluate(BaselineThrottle.Read(), DateTimeOffset.Now,
+ ConfigManager.Instance.Config.BaselineMinIntervalHours, forced);
+ if (throttle.Skip)
+ {
+ Logger.WriteSkipped($"Baseline throttle: skipping this run: {throttle.Reason}");
+ RunReport.SetRunType(RunTypes.Skip);
+ StatusManager.SetPhaseStatus(InstallationPhase.SetupAssistant, InstallationStage.Skipped);
+ StatusManager.SetPhaseStatus(InstallationPhase.Userland, InstallationStage.Skipped);
+ Logger.WriteCompletion("Nothing downloaded: baseline throttled");
+ StatusManager.WriteSuccessfulCompletionRegistry();
+ await ReportManager.SendRunSummaryAsync(true, runStartUtc, Version, manifestUrl);
+ RunReport.Finish();
+ return ExitSuccess;
+ }
+ Logger.Info($"Baseline throttle: running ({throttle.Reason})");
Logger.Info("Baseline mode: refreshing setupassistant items without a dialog; userland is skipped.");
}
else
@@ -1567,6 +1589,44 @@ static async Task DownloadFile(string displayName, string url, string localPath)
Logger.WriteSubProgress("Downloaded", sizeText);
}
+ ///
+ /// The same checks as , from manifest fields only:
+ /// the item's hash is in the install ledger, or an MSI item's
+ /// productCode/upgradeCode is installed at its version or newer.
+ /// Null when the manifest does not say enough, and the file is downloaded and
+ /// checked after.
+ ///
+ static string? BaselineSkipReasonBeforeDownload(JsonElement packageInfo, string type)
+ {
+ string? Field(string name) =>
+ packageInfo.ValueKind == JsonValueKind.Object &&
+ packageInfo.TryGetProperty(name, out var p) && p.ValueKind == JsonValueKind.String
+ ? p.GetString() : null;
+
+ var hash = Field("hash");
+ if (!string.IsNullOrWhiteSpace(hash))
+ {
+ var bare = hash.Trim();
+ if (bare.StartsWith("sha256:", StringComparison.OrdinalIgnoreCase)) bare = bare[7..];
+ if (new InstallLedger().Contains(bare))
+ return "this file was already installed by BootstrapMate";
+ }
+
+ var version = Field("version");
+ var productCode = Field("productCode");
+ var upgradeCode = Field("upgradeCode");
+ if (type.Equals("msi", StringComparison.OrdinalIgnoreCase) &&
+ !string.IsNullOrWhiteSpace(version) &&
+ (!string.IsNullOrWhiteSpace(productCode) || !string.IsNullOrWhiteSpace(upgradeCode)))
+ {
+ var product = new MsiProduct.Info(productCode ?? "", version!, upgradeCode, PackageLabel(packageInfo));
+ if (MsiProduct.IsInstalledAtOrAbove(product, out var installed))
+ return $"version {installed} is installed (manifest version {version})";
+ }
+
+ return null;
+ }
+
///
/// Why a baseline run can leave this file alone, or null when it must install it:
/// the same file is in the install ledger, or its MSI product is already
@@ -1599,6 +1659,14 @@ static async Task DownloadAndInstallPackage(string displayName, string url
try
{
+ // Baseline: decide from the manifest alone when possible, so an item that is
+ // already in place costs no download.
+ if (baseline && BaselineSkipReasonBeforeDownload(packageInfo, type) is { } earlySkip)
+ {
+ Logger.WriteSkipped($"{displayName} - {earlySkip} (not downloaded)");
+ return false;
+ }
+
DialogManager.Instance.NotifyDownloadStarted(displayName);
await DownloadFile(displayName, url, localPath);
diff --git a/README.md b/README.md
index f71085e..7ec764b 100644
--- a/README.md
+++ b/README.md
@@ -173,8 +173,11 @@ the preflight has decided, it is rewritten with `skip`, `baseline` or
run. It is written atomically when the run starts, with status `running`, and
again when the session closes. At the start, `end_time` and `duration_seconds` are
`null` and `items` is empty. Its status values match `session.json`: `running`,
-`completed`, `partial_failure` (some items failed), and `failed` (the preflight
-failed or the manifest would not load). The time in the `--last-run` line is UTC
+`completed`, `partial_failure` (some items failed), `failed` (the preflight
+failed or the manifest would not load), and `interrupted`: a run that died without
+recording its end (a reboot, a killed process). The next run finds the record still
+at `running`, relabels that run's `session.json`, and logs a warning before it
+writes its own record. The time in the `--last-run` line is UTC
to the minute.
```json
@@ -214,6 +217,46 @@ install run started without elevation and without an interactive console (a scri
a remote shell, redirected input) exits `3` instead of waiting at the elevation
prompt.
+## Baseline throttle
+
+Every baseline run downloads from the package host, so baselines are rate-limited.
+The check runs only after the preflight has chosen baseline, so provisioning is never
+limited. It reads `C:\ProgramData\ManagedBootstrap\baseline.json`, which holds the
+last baseline's `end_time`, `status` and `consecutive_failures`. `last-run.json`
+cannot hold the clock, because every run rewrites it.
+
+| Last baseline | Next baseline |
+|---|---|
+| Completed less than `BaselineMinIntervalHours` ago (default 144) | Skips |
+| Failed, partially failed or interrupted for the first time | One retry after 24 hours, never sooner |
+| Failed again after that retry | Waits the full interval |
+| None: a provisioning run clears the record | Runs |
+| Any, with `C:\ProgramData\ManagedBootstrap\.bootstrap_force` present | Runs; the preflight consumes the file |
+
+A throttled run fetches the manifest and runs the preflight, then downloads nothing.
+It logs why, ends as `skip`, records SetupAssistant and Userland as `Skipped` in
+`status.json`, and leaves `baseline.json` alone. `--force` does not bypass the
+throttle. `BaselineMinIntervalHours` comes from policy or the settings registry
+(0-8760; 0 disables the limit for completed runs).
+
+A baseline run also skips an item without downloading it when the manifest says
+enough: its `hash` is already in the install ledger, or an `msi` item's `productCode`
+or `upgradeCode` is installed at its `version` (the MSI ProductVersion) or newer.
+Without those fields, the file is downloaded and checked afterwards.
+
+## Versions
+
+Everything carries the build stamp `YYYY.MM.DD.HHMM`: file and assembly versions,
+`--version`, `HKLM\SOFTWARE\BootstrapMate\Version` (the Intune detection value),
+logs, `last-run.json` and release tags.
+
+The MSI ProductVersion is the only exception. Windows Installer fields are numeric
+(255.255.65535), and upgrades compare only the first three fields, so the MSI uses
+`YY.M.DDHH.MM`: `2026.10.04.1951` is `26.10.419.51`. Upgrades compare to the hour.
+Two builds made in the same hour compare equal and do not upgrade each other, so
+publish at most one build per hour. Pass `-p:FullVersion=YYYY.MM.DD.HHMM` to the
+installer project; it derives the ProductVersion.
+
## Downloads
Package downloads stream to disk with no overall HTTP timeout. An attempt fails when
diff --git a/RunReport.cs b/RunReport.cs
index 7ac2fbb..65b3fc5 100644
--- a/RunReport.cs
+++ b/RunReport.cs
@@ -17,6 +17,7 @@ public static void Start(string version)
{
lock (_lock)
{
+ RecoverInterruptedRun();
_record = new LastRunRecord
{
SessionId = Logger.GetSessionId() ?? "",
@@ -29,6 +30,26 @@ public static void Start(string version)
}
}
+ ///
+ /// A last-run.json still at "running" belongs to a run that died: this run holds the
+ /// single-instance lock, so none other is going. Its session is relabelled
+ /// "interrupted", and an interrupted baseline counts as a failed one, so the throttle
+ /// gives it one retry a day later instead of letting whatever killed it loop.
+ ///
+ private static void RecoverInterruptedRun()
+ {
+ var orphan = LastRunFile.MarkInterrupted(LastRunFile.Read(), Logger.LogDirectory);
+ if (orphan is null) return;
+
+ Logger.Warning($"Previous run {orphan.SessionId} ({orphan.RunType}, started {orphan.StartTime}) " +
+ "never finished; recorded as interrupted");
+ if (string.Equals(orphan.RunType, RunTypes.Baseline, StringComparison.OrdinalIgnoreCase))
+ {
+ var when = DateTimeOffset.TryParse(orphan.StartTime, out var started) ? started : DateTimeOffset.Now;
+ BaselineThrottle.Write(BaselineThrottle.After(BaselineThrottle.Read(), RunStatuses.Interrupted, when));
+ }
+ }
+
public static void SetRunType(string runType)
{
Logger.SetRunType(runType);
@@ -72,6 +93,13 @@ public static void Finish(string? status = null)
_record.Errors = outcome.Errors;
_record.Warnings = outcome.Warnings;
LastRunFile.Write(_record);
+
+ // The baseline clock: a baseline sets it, a provisioning run clears it (a
+ // machine provisioned again starts over), a skip leaves it alone.
+ if (_record.RunType == RunTypes.Baseline)
+ BaselineThrottle.Write(BaselineThrottle.After(BaselineThrottle.Read(), outcome.Status, new DateTimeOffset(outcome.End)));
+ else if (_record.RunType == RunTypes.Provisioning && outcome.Status == RunStatuses.Completed)
+ BaselineThrottle.Clear();
}
}
diff --git a/build.ps1 b/build.ps1
index e2ff128..b2aeda1 100644
--- a/build.ps1
+++ b/build.ps1
@@ -1507,14 +1507,10 @@ function Update-Version {
$newVersion = "$year.$month.$day.$revision"
Write-Log "Updating version to: $newVersion (YYYY.MM.DD.HHMM format for Intune compatibility)" "INFO"
- # Create MSI-compatible version (major.minor.build < 65536)
- # Convert YYYY.MM.DD.HHMM to YY.MM.DD.HHMM for MSI ProductVersion
- $now = Get-Date
- $msiMajor = $now.Year - 2000 # e.g., 25 for 2025
- $msiMinor = [int]$now.ToString("MM") # e.g., 9 for September
- $msiBuild = [int]$now.ToString("dd") # e.g., 2 for 2nd day
- $msiRevision = [int]$now.ToString("HHmm") # e.g., 2141 for 21:41
- $msiVersion = "$msiMajor.$msiMinor.$msiBuild.$msiRevision"
+ # MSI ProductVersion is YY.M.DDHH.MM (Windows Installer compares only the first
+ # three fields, so the hour has to be in them). The wixproj derives the same value
+ # from FullVersion; this copy is only for the log.
+ $msiVersion = "{0}.{1}.{2}.{3}" -f ($now.Year - 2000), $now.Month, ($now.Day * 100 + $now.Hour), $now.Minute
Write-Log "MSI ProductVersion: $msiVersion (MSI-compliant format)" "INFO"
@@ -1536,7 +1532,7 @@ function Update-Version {
# Return version information regardless of whether static version was found
return @{
FullVersion = $newVersion # YYYY.MM.DD.HHMM for Intune detection
- MsiVersion = $msiVersion # YY.MM.DD.HHMM for MSI ProductVersion
+ MsiVersion = $msiVersion # YY.M.DDHH.MM for MSI ProductVersion
}
}
@@ -1571,7 +1567,7 @@ function Build-MSI {
"--configuration", "Release",
"--verbosity", "normal",
"-p:Platform=$Arch",
- "-p:ProductVersion=$($versionInfo.MsiVersion)",
+ "-p:FullVersion=$($versionInfo.FullVersion)",
"-p:BinDir=$binDirAbsolute"
)
if ($appDirAbsolute) {
diff --git a/installer/BootstrapMate.Installer.wixproj b/installer/BootstrapMate.Installer.wixproj
index 1e40ff0..fc11453 100644
--- a/installer/BootstrapMate.Installer.wixproj
+++ b/installer/BootstrapMate.Installer.wixproj
@@ -11,14 +11,23 @@
+
+ $([System.Text.RegularExpressions.Regex]::Replace('$(FullVersion)', '^20(\d\d)\.0?(\d{1,2})\.0?(\d{1,2})\.(\d\d)0?(\d{1,2})$', '$1.$2.$3$4.$5'))
0.0.0
+ $(ProductVersion)
$(MSBuildProjectDirectory)\..\publish\executables\$(Platform)
$(MSBuildProjectDirectory)\..\publish\app\$(Platform)
$(MSBuildProjectDirectory)\sbin-staging
- BIN_DIR=$(BinDir);APP_DIR=$(AppDir);SBIN_DIR=$(SbinDir);ProductVersion=$(ProductVersion)
+ BIN_DIR=$(BinDir);APP_DIR=$(AppDir);SBIN_DIR=$(SbinDir);ProductVersion=$(ProductVersion);FullVersion=$(FullVersion)
diff --git a/installer/Product.wxs b/installer/Product.wxs
index 7cc6852..1be9831 100644
--- a/installer/Product.wxs
+++ b/installer/Product.wxs
@@ -7,6 +7,9 @@
+
+
+
-
+
-
+
Default: C:\Program Files\BootstrapMate
+ Minimum Hours Between Baseline Runs
+ A baseline run that starts less than this many hours after the last completed baseline exits as a skip before downloading anything. A failed, partially failed or interrupted baseline gets one retry after 24 hours, never sooner; if that retry fails too, the full interval applies. Provisioning runs are not limited. While C:\ProgramData\ManagedBootstrap\.bootstrap_force is present the limit does not apply; the preflight consumes the file.
+
+Range: 0-8760 hours
+Default: 144 hours (6 days)
+
Network Timeout (seconds)
Timeout in seconds for the manifest request, and how long a package download may go without receiving data before the attempt fails and is retried. A large package keeps downloading for as long as data keeps arriving.
@@ -165,6 +171,9 @@ Default: Disabled
Timeout (seconds):
+
+ Hours between baseline runs:
+
diff --git a/src/BootstrapMate.Core/BaselineThrottle.cs b/src/BootstrapMate.Core/BaselineThrottle.cs
new file mode 100644
index 0000000..9afdc5b
--- /dev/null
+++ b/src/BootstrapMate.Core/BaselineThrottle.cs
@@ -0,0 +1,117 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace BootstrapMate.Core;
+
+///
+/// The last baseline run's outcome, kept apart from last-run.json because every run
+/// rewrites that file, a throttled one included, so it cannot hold the clock.
+/// The schema matches the macOS build's baseline.json.
+///
+public sealed class BaselineRecord
+{
+ [JsonPropertyName("end_time")] public string EndTime { get; set; } = "";
+ [JsonPropertyName("status")] public string Status { get; set; } = "";
+ [JsonPropertyName("consecutive_failures")] public int ConsecutiveFailures { get; set; }
+}
+
+///
+/// Keeps baseline runs from repeating. Every run downloads from the package host, so a
+/// machine that is already current must not baseline again on every trigger (the daily
+/// Self-Heal task, an Intune reinstall or retry). The rule matches the macOS build.
+///
+///
+/// Applied only after the preflight has chosen baseline, so provisioning is never limited:
+///
+/// - The .bootstrap_force file in ProgramData\ManagedBootstrap: run. The throttle
+/// only looks; the preflight consumes it.
+/// - No record: run. A provisioning run clears the record.
+/// - Last baseline completed less than BaselineMinIntervalHours ago (default 144): skip.
+/// - Last baseline failed, partially failed or was interrupted: one retry after 24 hours;
+/// if that retry fails too, the full interval applies again.
+///
+/// A throttled run leaves the record alone, so the last real baseline stays the reference.
+///
+public static class BaselineThrottle
+{
+ public const int DefaultMinIntervalHours = 144;
+ public const int FailedRetryHours = 24;
+
+ public static readonly string ForceFilePath = @"C:\ProgramData\ManagedBootstrap\.bootstrap_force";
+ public static readonly string DefaultRecordPath = @"C:\ProgramData\ManagedBootstrap\baseline.json";
+
+ public sealed record Decision(bool Skip, string Reason);
+
+ public static Decision Evaluate(BaselineRecord? last, DateTimeOffset now, int minIntervalHours, bool forced)
+ {
+ if (forced) return new(false, $"{ForceFilePath} is present");
+ if (last is null) return new(false, "no baseline recorded");
+ if (!DateTimeOffset.TryParse(last.EndTime, out var when))
+ return new(false, "last baseline has no readable time");
+
+ var age = now - when;
+ bool completed = string.Equals(last.Status, RunStatuses.Completed, StringComparison.OrdinalIgnoreCase);
+ var interval = TimeSpan.FromHours(Math.Max(0, minIntervalHours));
+ // The first failure earns one retry a day later; once that retry has been used,
+ // a failing machine waits the full interval like a healthy one.
+ var wait = completed || last.ConsecutiveFailures > 1
+ ? interval
+ : TimeSpan.FromHours(FailedRetryHours);
+
+ if (age < wait)
+ {
+ return new(true,
+ $"last baseline {last.Status} {age.TotalHours:F1}h ago, under the {wait.TotalHours:F0}h minimum; " +
+ $"next baseline allowed after {when + wait:yyyy-MM-dd HH:mm zzz}");
+ }
+
+ return new(false, $"last baseline {last.Status} {age.TotalHours:F1}h ago (limit {wait.TotalHours:F0}h)");
+ }
+
+ /// The record a finished baseline leaves, counting failures in a row.
+ public static BaselineRecord After(BaselineRecord? previous, string status, DateTimeOffset end) => new()
+ {
+ EndTime = end.ToString("yyyy-MM-ddTHH:mm:ss.fffzzz"),
+ Status = status,
+ ConsecutiveFailures = string.Equals(status, RunStatuses.Completed, StringComparison.OrdinalIgnoreCase)
+ ? 0
+ : (previous?.ConsecutiveFailures ?? 0) + 1
+ };
+
+ private static readonly JsonSerializerOptions WriteOptions = new() { WriteIndented = true };
+
+ /// The record at , or null when it is absent or unreadable.
+ public static BaselineRecord? Read(string? path = null)
+ {
+ try
+ {
+ var target = path ?? DefaultRecordPath;
+ return File.Exists(target) ? JsonSerializer.Deserialize(File.ReadAllText(target)) : null;
+ }
+ catch
+ {
+ return null;
+ }
+ }
+
+ /// Writes through a temporary file and a rename. Failure is swallowed.
+ public static void Write(BaselineRecord record, string? path = null)
+ {
+ var target = path ?? DefaultRecordPath;
+ try
+ {
+ var directory = Path.GetDirectoryName(target);
+ if (!string.IsNullOrEmpty(directory)) Directory.CreateDirectory(directory);
+ File.WriteAllText(target + ".tmp", JsonSerializer.Serialize(record, WriteOptions));
+ File.Move(target + ".tmp", target, overwrite: true);
+ }
+ catch
+ {
+ }
+ }
+
+ public static void Clear(string? path = null)
+ {
+ try { File.Delete(path ?? DefaultRecordPath); } catch { }
+ }
+}
diff --git a/src/BootstrapMate.Core/BootstrapMateConfig.cs b/src/BootstrapMate.Core/BootstrapMateConfig.cs
index 92a01db..5091bc2 100644
--- a/src/BootstrapMate.Core/BootstrapMateConfig.cs
+++ b/src/BootstrapMate.Core/BootstrapMateConfig.cs
@@ -39,6 +39,12 @@ public sealed class BootstrapMateConfig
///
public int NetworkTimeout { get; set; } = BootstrapMateConstants.DefaultNetworkTimeout;
+ ///
+ /// Minimum hours between completed baseline runs; a failed baseline retries after 24.
+ /// See .
+ ///
+ public int BaselineMinIntervalHours { get; set; } = BaselineThrottle.DefaultMinIntervalHours;
+
/// Creates a deep copy of this configuration.
public BootstrapMateConfig Clone() => (BootstrapMateConfig)MemberwiseClone();
}
diff --git a/src/BootstrapMate.Core/ConfigManager.cs b/src/BootstrapMate.Core/ConfigManager.cs
index 054d544..2d8daaa 100644
--- a/src/BootstrapMate.Core/ConfigManager.cs
+++ b/src/BootstrapMate.Core/ConfigManager.cs
@@ -163,6 +163,7 @@ void WriteInt(string key, int value)
WriteBool("BlurScreen", settings.BlurScreen);
WriteString("CustomInstallPath", settings.CustomInstallPath);
WriteInt("NetworkTimeout", settings.NetworkTimeout);
+ WriteInt("BaselineMinIntervalHours", settings.BaselineMinIntervalHours);
WriteString("ReportingUrl", settings.ReportingUrl);
WriteString("ReportingHeader", settings.ReportingHeader);
WriteBool("VerifyPackageSignatures", settings.VerifyPackageSignatures);
@@ -241,6 +242,9 @@ private void LoadFromManagement(ManagementDetector management)
if (management.GetManagedInt("NetworkTimeout") is { } timeout)
Config.NetworkTimeout = timeout;
+ if (management.GetManagedInt("BaselineMinIntervalHours") is { } baselineHours)
+ Config.BaselineMinIntervalHours = baselineHours;
+
if (management.GetManagedString("ReportingUrl") is { Length: > 0 } reportingUrl)
Config.ReportingUrl = reportingUrl;
@@ -302,6 +306,7 @@ private void LoadFromHive(RegistryHive hive, ConfigSource source, RegistryView v
Config.BlurScreen = ReadBool(settingsKey, "BlurScreen") ?? Config.BlurScreen;
Config.CustomInstallPath = ReadString(settingsKey, "CustomInstallPath") ?? Config.CustomInstallPath;
Config.NetworkTimeout = ReadInt(settingsKey, "NetworkTimeout") ?? Config.NetworkTimeout;
+ Config.BaselineMinIntervalHours = ReadInt(settingsKey, "BaselineMinIntervalHours") ?? Config.BaselineMinIntervalHours;
Config.ReportingUrl = ReadString(settingsKey, "ReportingUrl") ?? Config.ReportingUrl;
Config.ReportingHeader = ReadString(settingsKey, "ReportingHeader") ?? Config.ReportingHeader;
Config.VerifyPackageSignatures = ReadBool(settingsKey, "VerifyPackageSignatures") ?? Config.VerifyPackageSignatures;
diff --git a/src/BootstrapMate.Core/LastRun.cs b/src/BootstrapMate.Core/LastRun.cs
index f4ad724..1078319 100644
--- a/src/BootstrapMate.Core/LastRun.cs
+++ b/src/BootstrapMate.Core/LastRun.cs
@@ -57,6 +57,11 @@ public static class RunStatuses
public const string PartialFailure = "partial_failure";
/// The run could not do its work: a failed preflight, or a manifest that would not load.
public const string Failed = "failed";
+ ///
+ /// The run died without recording its end (a reboot, a killed process, an MSI upgrade).
+ /// Set by the next run, which finds the record still at .
+ ///
+ public const string Interrupted = "interrupted";
}
public static class ItemResults
@@ -117,6 +122,45 @@ public static void Write(LastRunRecord record, string? path = null)
}
}
+ ///
+ /// A record left at by a run that is no longer going,
+ /// relabelled ; null when the record finished.
+ /// Only call this while holding the single-instance lock, so no live run is mistaken
+ /// for a dead one. Its session.json under is relabelled too.
+ ///
+ public static LastRunRecord? MarkInterrupted(LastRunRecord? record, string? logsDirectory = null)
+ {
+ if (record is null || !string.Equals(record.Status, RunStatuses.Running, StringComparison.OrdinalIgnoreCase))
+ return null;
+
+ record.Status = RunStatuses.Interrupted;
+ if (logsDirectory is not null && SessionDirectory(logsDirectory, record.SessionId) is { } dir)
+ {
+ try
+ {
+ var sessionFile = Path.Combine(dir, "session.json");
+ if (File.Exists(sessionFile) &&
+ System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(sessionFile)) is System.Text.Json.Nodes.JsonObject session &&
+ (string?)session["status"] == RunStatuses.Running)
+ {
+ session["status"] = RunStatuses.Interrupted;
+ File.WriteAllText(sessionFile, session.ToJsonString(WriteOptions));
+ }
+ }
+ catch
+ {
+ }
+ }
+ return record;
+ }
+
+ /// Session 2026-10-05-030002 lives in logs/2026-10-05/030002.
+ public static string? SessionDirectory(string logsDirectory, string sessionId)
+ {
+ if (sessionId.Length < 12 || sessionId[10] != '-') return null;
+ return Path.Combine(logsDirectory, sessionId[..10], sessionId[11..]);
+ }
+
/// First line of an error, trimmed to .
public static string ShortError(string? error)
{
diff --git a/src/BootstrapMate.Core/ManagementDetector.cs b/src/BootstrapMate.Core/ManagementDetector.cs
index 7b8b60e..5fbade7 100644
--- a/src/BootstrapMate.Core/ManagementDetector.cs
+++ b/src/BootstrapMate.Core/ManagementDetector.cs
@@ -35,6 +35,7 @@ public sealed class ManagementDetector
["BlurScreen"] = ["BlurScreen"],
["CustomInstallPath"] = ["CustomInstallPath", "InstallPath", "iapath"],
["NetworkTimeout"] = ["NetworkTimeout"],
+ ["BaselineMinIntervalHours"] = ["BaselineMinIntervalHours"],
["ReportingUrl"] = ["ReportingUrl", "ReportURL", "reportingUrl"],
["ReportingHeader"] = ["ReportingHeader", "ReportingAuthorizationHeader"],
["VerifyPackageSignatures"] = ["VerifyPackageSignatures", "VerifySignatures"],
diff --git a/tests/BootstrapMate.Core.Tests/BaselineThrottleTests.cs b/tests/BootstrapMate.Core.Tests/BaselineThrottleTests.cs
new file mode 100644
index 0000000..4bfbbda
--- /dev/null
+++ b/tests/BootstrapMate.Core.Tests/BaselineThrottleTests.cs
@@ -0,0 +1,156 @@
+using BootstrapMate.Core;
+using Xunit;
+
+namespace BootstrapMate.Core.Tests;
+
+public class BaselineThrottleTests
+{
+ private static readonly DateTimeOffset Now = new(2026, 10, 5, 3, 0, 0, TimeSpan.FromHours(-7));
+
+ private static BaselineRecord Record(string status, double hoursAgo, int failures = 0) => new()
+ {
+ Status = status,
+ EndTime = Now.AddHours(-hoursAgo).ToString("yyyy-MM-ddTHH:mm:ss.fffzzz"),
+ ConsecutiveFailures = failures
+ };
+
+ private static BaselineThrottle.Decision Eval(BaselineRecord? last, bool forced = false, int interval = 144) =>
+ BaselineThrottle.Evaluate(last, Now, interval, forced);
+
+ [Fact]
+ public void AYoungCompletedBaselineSkips()
+ {
+ var d = Eval(Record(RunStatuses.Completed, 24));
+ Assert.True(d.Skip);
+ Assert.Contains("next baseline allowed after", d.Reason);
+ }
+
+ [Fact]
+ public void AnOldCompletedBaselineRuns() =>
+ Assert.False(Eval(Record(RunStatuses.Completed, 145)).Skip);
+
+ [Theory]
+ [InlineData(RunStatuses.Failed)]
+ [InlineData(RunStatuses.PartialFailure)]
+ [InlineData(RunStatuses.Interrupted)]
+ public void AFirstFailureRetriesOnceAfter24Hours(string status)
+ {
+ Assert.True(Eval(Record(status, 23, failures: 1)).Skip);
+ Assert.False(Eval(Record(status, 25, failures: 1)).Skip);
+ }
+
+ [Fact]
+ public void OnceTheRetryIsUsedTheFullIntervalApplies()
+ {
+ Assert.True(Eval(Record(RunStatuses.Failed, 25, failures: 2)).Skip);
+ Assert.True(Eval(Record(RunStatuses.Interrupted, 143, failures: 5)).Skip);
+ Assert.False(Eval(Record(RunStatuses.Failed, 145, failures: 2)).Skip);
+ }
+
+ [Fact]
+ public void AFailedBaselineNeverRetriesSoonerThan24HoursEvenWithAShortInterval() =>
+ Assert.True(Eval(Record(RunStatuses.Failed, 2, failures: 1), interval: 1).Skip);
+
+ [Fact]
+ public void TheForceFileAlwaysRuns()
+ {
+ var d = Eval(Record(RunStatuses.Completed, 1), forced: true);
+ Assert.False(d.Skip);
+ Assert.Contains(".bootstrap_force", d.Reason);
+ }
+
+ [Fact]
+ public void NoRecordRuns() => Assert.False(Eval(null).Skip);
+
+ [Fact]
+ public void AnUnreadableTimeDoesNotBlockTheRun()
+ {
+ var last = Record(RunStatuses.Completed, 1);
+ last.EndTime = "garbage";
+ Assert.False(Eval(last).Skip);
+ }
+
+ [Fact]
+ public void ZeroIntervalTurnsTheThrottleOffForCompletedRuns() =>
+ Assert.False(Eval(Record(RunStatuses.Completed, 0.1), interval: 0).Skip);
+
+ [Fact]
+ public void TheDefaultIntervalIsSixDays() =>
+ Assert.Equal(144, new BootstrapMateConfig().BaselineMinIntervalHours);
+
+ [Fact]
+ public void FailuresCountUntilABaselineCompletes()
+ {
+ var first = BaselineThrottle.After(null, RunStatuses.Failed, Now);
+ Assert.Equal(1, first.ConsecutiveFailures);
+ var second = BaselineThrottle.After(first, RunStatuses.Interrupted, Now);
+ Assert.Equal(2, second.ConsecutiveFailures);
+ Assert.Equal(0, BaselineThrottle.After(second, RunStatuses.Completed, Now).ConsecutiveFailures);
+ }
+
+ [Fact]
+ public void TheRecordSurvivesAWriteAndRead()
+ {
+ var path = Path.Combine(Path.GetTempPath(), $"baseline-{Guid.NewGuid():N}.json");
+ try
+ {
+ BaselineThrottle.Write(Record(RunStatuses.PartialFailure, 3, failures: 1), path);
+ var read = BaselineThrottle.Read(path);
+ Assert.NotNull(read);
+ Assert.Equal(RunStatuses.PartialFailure, read!.Status);
+ Assert.Equal(1, read.ConsecutiveFailures);
+ Assert.Contains("\"consecutive_failures\"", File.ReadAllText(path));
+ BaselineThrottle.Clear(path);
+ Assert.Null(BaselineThrottle.Read(path));
+ }
+ finally
+ {
+ File.Delete(path);
+ }
+ }
+}
+
+public class InterruptedRunTests
+{
+ [Fact]
+ public void ARunStillMarkedRunningIsRelabelledInterrupted()
+ {
+ var root = Path.Combine(Path.GetTempPath(), $"logs-{Guid.NewGuid():N}");
+ var sessionDir = Path.Combine(root, "2026-10-05", "030002");
+ Directory.CreateDirectory(sessionDir);
+ var sessionFile = Path.Combine(sessionDir, "session.json");
+ File.WriteAllText(sessionFile, "{\"session_id\":\"2026-10-05-030002\",\"status\":\"running\"}");
+ try
+ {
+ var record = new LastRunRecord { SessionId = "2026-10-05-030002", RunType = RunTypes.Baseline, Status = RunStatuses.Running };
+ var marked = LastRunFile.MarkInterrupted(record, root);
+ Assert.NotNull(marked);
+ Assert.Equal(RunStatuses.Interrupted, marked!.Status);
+ Assert.Contains("\"interrupted\"", File.ReadAllText(sessionFile));
+ }
+ finally
+ {
+ Directory.Delete(root, recursive: true);
+ }
+ }
+
+ [Theory]
+ [InlineData(RunStatuses.Completed)]
+ [InlineData(RunStatuses.Failed)]
+ [InlineData(RunStatuses.PartialFailure)]
+ public void AFinishedRunIsLeftAlone(string status) =>
+ Assert.Null(LastRunFile.MarkInterrupted(new LastRunRecord { Status = status }));
+
+ [Fact]
+ public void NoRecordIsNotAnInterruption() => Assert.Null(LastRunFile.MarkInterrupted(null));
+
+ [Theory]
+ [InlineData("2026-10-05-030002", "2026-10-05", "030002")]
+ [InlineData("2026-10-05-030002_2", "2026-10-05", "030002_2")]
+ public void ASessionIdNamesItsDirectory(string id, string day, string time) =>
+ Assert.Equal(Path.Combine("logs", day, time), LastRunFile.SessionDirectory("logs", id));
+
+ [Fact]
+ public void AnUnrecognisedSessionIdHasNoDirectory() =>
+ Assert.Null(LastRunFile.SessionDirectory("logs", ""));
+}