delivery-friction-analyzer 0.11.0 → 0.12.1

package/docs/reference/repository-profile.md

@@ -4,6 +4,8 @@ Repository profiles map paths to file categories, file roles, and functional sur
 
 Schema: `schemas/repository-profile.schema.json`.
 
+Repository profiles own repository semantics. Keep file rules, PR class rules, workflow context, branch or release strategy, and contributor-source declarations here. Optional [run presets](run-presets.md) only store reusable run settings such as the target repository, profile path, sample size, output directory, dry-run mode, CSV preference, JSON completion preference, validation-target mode, and requested PR class exclusions. Explicit CLI flags override preset values.
+
 ## Categories
 
 - `code`

package/docs/reference/run-presets.md

@@ -0,0 +1,91 @@
+# Run Presets
+
+Run presets are optional local JSON files for reusing CLI run settings. They are intended for rerunning the same analysis without re-answering interactive prompts.
+
+Repository meaning stays in repository profiles. Put file rules, PR class rules, workflow context, branch or release strategy, and contributor-source declarations in a repository profile. A run preset may only point at a profile and store run inputs or preferences such as the target repository, sample size, output directory, dry-run mode, CSV preference, JSON completion preference, validation-target mode, and requested PR class exclusions.
+
+## Save A Preset
+
+Interactive setup asks whether to save a local run preset near the end of the prompt flow. If you answer yes, you choose the preset path explicitly. The CLI does not invent a global or cloud-synced preset location.
+
+Saving a preset may overwrite an existing regular file at that path, but the path must not be a directory, symbolic link, or other special file.
+
+You can also save a preset from flags:
+
+```sh
+npm run analyze:github -- \
+  --repo example/example-repo \
+  --limit 30 \
+  --profile profiles/example-repo.json \
+  --out reports/example-repo \
+  --save-preset .delivery-friction-analyzer/example-repo.run-preset.json
+```
+
+When a preset is written, the completion output includes:
+
+```text
+Run preset saved: .delivery-friction-analyzer/example-repo.run-preset.json.
+```
+
+With `--json`, the same path is emitted as `savedRunPresetPath` in the machine-readable completion receipt.
+
+## Rerun From A Preset
+
+Use `--preset <path>` to load saved settings without prompts:
+
+```sh
+npm run analyze:github -- --preset .delivery-friction-analyzer/example-repo.run-preset.json
+```
+
+Explicit CLI flags override preset values. This makes one-off reruns predictable:
+
+```sh
+npm run analyze:github -- \
+  --preset .delivery-friction-analyzer/example-repo.run-preset.json \
+  --limit 10 \
+  --no-csv
+```
+
+In that command, the preset still supplies values such as `--repo`, `--profile`, and `--out`, while `--limit 10` and `--no-csv` win over the saved sample size and CSV preference.
+
+Boolean preset values can be overridden in either direction:
+
+- `--dry-run` or `--no-dry-run`
+- `--validation-target` or `--no-validation-target`
+- `--csv` or `--no-csv`
+- `--json` or `--no-json`
+
+If both forms are provided in one command, the later flag wins. For example, `--preset local.json --dry-run --no-dry-run` runs a full analysis, while `--preset local.json --no-csv --csv` writes CSV evidence files.
+
+## Format
+
+Preset files use `analyze-github-run-preset.v1`:
+
+```json
+{
+  "schemaVersion": "analyze-github-run-preset.v1",
+  "run": {
+    "repository": "example/example-repo",
+    "limit": 30,
+    "profilePath": "profiles/example-repo.json",
+    "outDir": "reports/example-repo",
+    "dryRun": false,
+    "isValidationTarget": false,
+    "csv": true,
+    "json": false,
+    "excludedPrClasses": []
+  }
+}
+```
+
+The CLI only reads and writes the allowlisted `run` keys shown above. Presets must not contain GitHub tokens, secrets, raw source bundles, normalized data, metrics, reports, methodology text, CSV contents, contributor file contents, or repository profile rules.
+
+## Cleanup
+
+Preset files are local user-owned files. Delete a preset when it no longer matches how you want to run the analyzer:
+
+```sh
+rm .delivery-friction-analyzer/example-repo.run-preset.json
+```
+
+Deleting a preset does not delete generated reports or repository profiles. If a preset points at a generated profile, review and clean up that profile separately.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delivery-friction-analyzer",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Local GitHub pull request analytics for delivery friction reports.",
   "license": "MIT",
   "type": "module",

package/release-log.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+### 2026-06-20 — Reusable Run Presets
+
+- What changed: GitHub analysis can now load local run settings from `--preset` and save reusable settings with `--save-preset` or the interactive setup flow, with explicit CLI flags taking precedence.
+- Why it matters: Maintainers can rerun an interactive setup non-interactively without moving repository semantics out of repository profiles.
+- Who is affected: Maintainers using `--interactive` or repeated local analysis commands.
+- Action needed: Optional; save a local preset for repeated runs and delete stale preset files when they no longer match the desired analysis settings.
+- PR: #48
+
 ### 2026-06-20 — Contributor Source Configuration
 
 - What changed: Repository profiles can now configure `.all-contributorsrc` as a structured contributor source, and analysis records contributor-source coverage while using sanitized hints only for aggregate comment-source classification.

package/src/cli/analyze-github.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { constants, realpathSync } from "node:fs";
-import { access, lstat, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, lstat, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -26,18 +26,71 @@ import {
 } from "../profile/workflow.js";
 import { assertValidContributorSource } from "../profile/contributor-source.js";
 
+const RUN_PRESET_SCHEMA_VERSION = "analyze-github-run-preset.v1";
+
 const ALLOWED_OPTIONS = new Set([
   "repo",
   "limit",
   "profile",
   "out",
   "dry-run",
+  "no-dry-run",
   "metadata-only",
   "validation-target",
+  "no-validation-target",
+  "csv",
   "no-csv",
   "exclude-pr-class",
   "json",
+  "no-json",
   "interactive",
+  "preset",
+  "save-preset",
+]);
+
+const BOOLEAN_OPTIONS = new Set([
+  "dry-run",
+  "no-dry-run",
+  "metadata-only",
+  "validation-target",
+  "no-validation-target",
+  "csv",
+  "no-csv",
+  "json",
+  "no-json",
+  "interactive",
+]);
+
+const CLI_OPTION_KEYS = Object.freeze({
+  repo: "repository",
+  limit: "limit",
+  profile: "profilePath",
+  out: "outDir",
+  "dry-run": "dryRun",
+  "no-dry-run": "dryRun",
+  "metadata-only": "dryRun",
+  "validation-target": "isValidationTarget",
+  "no-validation-target": "isValidationTarget",
+  csv: "csv",
+  "no-csv": "csv",
+  "exclude-pr-class": "excludedPrClasses",
+  json: "json",
+  "no-json": "json",
+  interactive: "interactive",
+  preset: "presetPath",
+  "save-preset": "savePresetPath",
+});
+
+const RUN_PRESET_OPTION_KEYS = Object.freeze([
+  "repository",
+  "limit",
+  "profilePath",
+  "outDir",
+  "dryRun",
+  "isValidationTarget",
+  "csv",
+  "json",
+  "excludedPrClasses",
 ]);
 
 const REPOSITORY_SLUG = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/;
@@ -72,16 +125,58 @@ Options:
   --profile <path>          Repository profile JSON used for file role classification.
   --out <directory>         Output directory for generated artifacts.
   --dry-run                 Validate inputs and sample GitHub coverage without writing artifacts.
+  --no-dry-run              Disable dry-run mode when a preset enabled it.
   --metadata-only           Alias for --dry-run.
   --validation-target       Mark the target repository as a validation target in output metadata.
+  --no-validation-target    Disable validation-target mode when a preset enabled it.
   --exclude-pr-class <cls>  Exclude a PR class from normalized, metrics, report, methodology, and CSV artifacts. Repeat or comma-separate values.
+  --csv                     Enable curated CSV evidence exports when a preset disabled them.
   --no-csv                  Suppress curated CSV evidence exports.
   --json                    Print the machine-readable completion receipt to stdout.
+  --no-json                 Disable JSON completion output when a preset enabled it.
   --interactive             Prompt for missing run options in a terminal.
+  --preset <path>           Load local run settings from a saved preset. Explicit CLI flags override preset values.
+  --save-preset <path>      Save local run settings for non-interactive reruns.
 `;
 
+function attachOptionSource(options, property, value) {
+  Object.defineProperty(options, property, {
+    value,
+    enumerable: false,
+    configurable: true,
+  });
+  return options;
+}
+
+function optionSourceSet(options, property) {
+  return options?.[property] instanceof Set ? options[property] : new Set();
+}
+
+function explicitCliOptionKeys(argv) {
+  const keys = new Set();
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") continue;
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    const optionKey = CLI_OPTION_KEYS[key];
+    if (optionKey) keys.add(optionKey);
+    if (!BOOLEAN_OPTIONS.has(key)) {
+      index += 1;
+    }
+  }
+  return keys;
+}
+
 export function parseAnalyzeGithubArgs(argv) {
-  const options = {};
+  const options = {
+    dryRun: false,
+    isValidationTarget: false,
+    csv: true,
+    json: false,
+    interactive: false,
+  };
+  const explicitOptions = explicitCliOptionKeys(argv);
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "--help" || arg === "-h") {
@@ -96,15 +191,16 @@ export function parseAnalyzeGithubArgs(argv) {
       throw new Error(`Unknown option: ${arg}`);
     }
 
-    if (
-      key === "dry-run"
-      || key === "metadata-only"
-      || key === "validation-target"
-      || key === "no-csv"
-      || key === "json"
-      || key === "interactive"
-    ) {
-      options[key] = true;
+    if (BOOLEAN_OPTIONS.has(key)) {
+      if (key === "dry-run" || key === "metadata-only") options.dryRun = true;
+      if (key === "no-dry-run") options.dryRun = false;
+      if (key === "validation-target") options.isValidationTarget = true;
+      if (key === "no-validation-target") options.isValidationTarget = false;
+      if (key === "csv") options.csv = true;
+      if (key === "no-csv") options.csv = false;
+      if (key === "json") options.json = true;
+      if (key === "no-json") options.json = false;
+      if (key === "interactive") options.interactive = true;
       continue;
     }
 
@@ -113,25 +209,29 @@ export function parseAnalyzeGithubArgs(argv) {
       throw new Error(`Missing value for ${arg}`);
     }
     if (key === "exclude-pr-class") {
-      options[key] = [...(options[key] ?? []), value];
+      options.excludedPrClasses = [...(options.excludedPrClasses ?? []), value];
     } else {
       options[key] = value;
     }
     index += 1;
   }
 
-  return {
+  const parsed = {
     repository: options.repo,
     limit: options.limit === undefined ? undefined : Number(options.limit),
     profilePath: options.profile,
     outDir: options.out,
-    dryRun: Boolean(options["dry-run"] || options["metadata-only"]),
-    isValidationTarget: Boolean(options["validation-target"]),
-    excludedPrClasses: normalizeExcludedPrClasses(options["exclude-pr-class"] ?? []),
-    csv: !options["no-csv"],
-    json: Boolean(options.json),
-    interactive: Boolean(options.interactive),
+    dryRun: options.dryRun,
+    isValidationTarget: options.isValidationTarget,
+    excludedPrClasses: normalizeExcludedPrClasses(options.excludedPrClasses ?? []),
+    csv: options.csv,
+    json: options.json,
+    interactive: options.interactive,
   };
+  if (options.preset !== undefined) parsed.presetPath = options.preset;
+  if (options["save-preset"] !== undefined) parsed.savePresetPath = options["save-preset"];
+
+  return attachOptionSource(parsed, "explicitCliOptions", explicitOptions);
 }
 
 function normalizeExcludedPrClasses(values) {
@@ -141,6 +241,164 @@ function normalizeExcludedPrClasses(values) {
     .filter(Boolean))];
 }
 
+function assertPlainObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+}
+
+function normalizePresetRunOptions(runOptions) {
+  assertPlainObject(runOptions, "preset run");
+  const unknown = Object.keys(runOptions).filter(key => !RUN_PRESET_OPTION_KEYS.includes(key));
+  if (unknown.length) {
+    throw new Error(`preset run contains unsupported key(s): ${unknown.join(", ")}`);
+  }
+
+  const normalized = {};
+  for (const key of RUN_PRESET_OPTION_KEYS) {
+    if (!Object.prototype.hasOwnProperty.call(runOptions, key)) continue;
+    const value = runOptions[key];
+    if (key === "limit") {
+      if (typeof value !== "number") throw new Error("preset run.limit must be a number.");
+      normalized.limit = value;
+    } else if (key === "dryRun" || key === "isValidationTarget" || key === "csv" || key === "json") {
+      if (typeof value !== "boolean") throw new Error(`preset run.${key} must be a boolean.`);
+      normalized[key] = value;
+    } else if (key === "excludedPrClasses") {
+      if (!Array.isArray(value)) throw new Error("preset run.excludedPrClasses must be an array.");
+      if (!value.every(item => typeof item === "string")) {
+        throw new Error("preset run.excludedPrClasses must contain only strings.");
+      }
+      normalized.excludedPrClasses = normalizeExcludedPrClasses(value);
+    } else {
+      if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`preset run.${key} must be a non-empty string.`);
+      }
+      normalized[key] = value.trim();
+    }
+  }
+
+  if (normalized.repository !== undefined) validateRepositorySlug(normalized.repository);
+  if (normalized.limit !== undefined) validateLimit(normalized.limit);
+  validateExcludedPrClasses(normalized.excludedPrClasses ?? []);
+  return normalized;
+}
+
+function parseRunPresetJson(text) {
+  let preset;
+  try {
+    preset = JSON.parse(text);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`preset must be valid JSON: ${error.message}`);
+    }
+    throw error;
+  }
+  assertPlainObject(preset, "preset");
+  if (preset.schemaVersion !== RUN_PRESET_SCHEMA_VERSION) {
+    throw new Error(`preset schemaVersion must be ${RUN_PRESET_SCHEMA_VERSION}.`);
+  }
+  const allowedTopLevel = new Set(["schemaVersion", "run"]);
+  const unknown = Object.keys(preset).filter(key => !allowedTopLevel.has(key));
+  if (unknown.length) {
+    throw new Error(`preset contains unsupported key(s): ${unknown.join(", ")}`);
+  }
+  return normalizePresetRunOptions(preset.run);
+}
+
+async function readRunPreset(presetPath) {
+  try {
+    const presetStat = await stat(presetPath);
+    if (!presetStat.isFile()) {
+      throw new Error("preset path must be a JSON file path, not a directory or special file.");
+    }
+    return parseRunPresetJson(await readFile(presetPath, "utf8"));
+  } catch (error) {
+    if (error.message?.startsWith("preset ")) throw error;
+    if (error.code === "ENOENT") {
+      throw new Error("preset could not be read: no such file or directory");
+    }
+    throw new Error(`preset could not be read: ${error.message}`);
+  }
+}
+
+async function mergeRunPresetOptions(options) {
+  if (!options.presetPath) return options;
+
+  const presetOptions = await readRunPreset(options.presetPath);
+  const explicitOptions = optionSourceSet(options, "explicitCliOptions");
+  const merged = { ...options };
+  const presetOptionKeys = new Set();
+  for (const key of RUN_PRESET_OPTION_KEYS) {
+    if (!Object.prototype.hasOwnProperty.call(presetOptions, key)) continue;
+    if (!explicitOptions.has(key)) {
+      merged[key] = presetOptions[key];
+    }
+    presetOptionKeys.add(key);
+  }
+  attachOptionSource(merged, "explicitCliOptions", explicitOptions);
+  attachOptionSource(merged, "presetOptionKeys", presetOptionKeys);
+  return merged;
+}
+
+function presetRunOptionsFromAnalyzeOptions(options) {
+  requireOptions(options);
+  validateRepositorySlug(options.repository);
+  validateLimit(options.limit);
+  validateExcludedPrClasses(options.excludedPrClasses ?? []);
+  return {
+    repository: options.repository,
+    limit: options.limit,
+    profilePath: options.profilePath,
+    outDir: options.outDir,
+    dryRun: Boolean(options.dryRun),
+    isValidationTarget: Boolean(options.isValidationTarget),
+    csv: options.csv !== false,
+    json: Boolean(options.json),
+    excludedPrClasses: [...(options.excludedPrClasses ?? [])],
+  };
+}
+
+function formatRunPreset(options) {
+  return `${JSON.stringify({
+    schemaVersion: RUN_PRESET_SCHEMA_VERSION,
+    run: presetRunOptionsFromAnalyzeOptions(options),
+  }, null, 2)}\n`;
+}
+
+async function writeRunPresetFile(presetPath, options) {
+  if (hasTrailingPathSeparator(presetPath)) {
+    throw new Error("preset path must be a JSON file path, not a directory or special file.");
+  }
+  await mkdir(dirname(presetPath), { recursive: true });
+  try {
+    const presetLinkStat = await lstat(presetPath);
+    if (!presetLinkStat.isFile()) {
+      throw new Error("preset path must be a JSON file path, not a directory or special file.");
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+
+  let file;
+  try {
+    file = await open(
+      presetPath,
+      constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW,
+      0o666,
+    );
+    await file.writeFile(formatRunPreset(options), "utf8");
+  } catch (error) {
+    if (error.code === "ELOOP" || error.code === "EISDIR") {
+      throw new Error("preset path must be a JSON file path, not a directory or special file.");
+    }
+    throw error;
+  } finally {
+    await file?.close();
+  }
+  return presetPath;
+}
+
 function requireOptions(options) {
   const missing = [];
   if (!options.repository) missing.push("--repo");
@@ -818,6 +1076,7 @@ export async function collectInteractiveAnalyzeGithubOptions(options, {
   output = process.stderr,
   isInteractiveTerminal = Boolean(input?.isTTY),
   onSavedProfilePath = null,
+  promptForRunPreset = false,
 } = {}) {
   if (!isInteractiveTerminal) {
     throw new Error("interactive mode requires a terminal. Re-run with --repo <owner/name> --limit <1-100> --profile <path> --out <directory>, or provide a TTY for prompts.");
@@ -970,6 +1229,36 @@ export async function collectInteractiveAnalyzeGithubOptions(options, {
       }
     }
 
+    if (promptForRunPreset && !resolved.savePresetPath) {
+      const shouldSavePreset = await askUntilValid(adapter, {
+        id: "saveRunPreset",
+        type: "confirm",
+        message: "Save local run preset for non-interactive reruns",
+        defaultValue: false,
+      }, {
+        output,
+        normalize: normalizeConfirmAnswer,
+        validate() {},
+      });
+      if (shouldSavePreset) {
+        resolved.savePresetPath = await askUntilValid(adapter, {
+          id: "runPresetPath",
+          type: "path",
+          message: "Run preset path",
+        }, {
+          output,
+          normalize: normalizeTextAnswer,
+          async validate(value) {
+            if (!value) throw new Error("Run preset path is required.");
+            if (hasTrailingPathSeparator(value)) {
+              throw new Error("preset path must be a JSON file path, not a directory or special file.");
+            }
+            await mkdir(dirname(value), { recursive: true });
+          },
+        });
+      }
+    }
+
     return resolved;
   } finally {
     if (ownsAdapter && typeof adapter.close === "function") {
@@ -1134,7 +1423,7 @@ function attachCollectionCoverage(report, sourceBundle) {
   };
 }
 
-function summarizeResult({ dryRun, outDir, paths, sourceBundle, metrics, report, requestedLimit, sampledLimit, csv, analysisFilter, savedProfilePath, prClassRulesWritten }) {
+function summarizeResult({ dryRun, outDir, paths, sourceBundle, metrics, report, requestedLimit, sampledLimit, csv, analysisFilter, savedProfilePath, savedRunPresetPath, prClassRulesWritten }) {
   const summary = {
     ok: true,
     dryRun,
@@ -1153,6 +1442,9 @@ function summarizeResult({ dryRun, outDir, paths, sourceBundle, metrics, report,
   if (savedProfilePath) {
     summary.savedProfilePath = savedProfilePath;
   }
+  if (savedRunPresetPath) {
+    summary.savedRunPresetPath = savedRunPresetPath;
+  }
   if (prClassRulesWritten) {
     summary.prClassRulesWritten = true;
   }
@@ -1230,6 +1522,7 @@ export async function runAnalyzeGithub(options, {
       csv: false,
       analysisFilter: null,
       savedProfilePath: options.savedProfilePath,
+      savedRunPresetPath: options.savedRunPresetPath,
       prClassRulesWritten: options.prClassRulesWritten,
     });
   }
@@ -1286,6 +1579,7 @@ export async function runAnalyzeGithub(options, {
     csv: csvEnabled,
     analysisFilter: normalized.analysisFilter ?? null,
     savedProfilePath: options.savedProfilePath,
+    savedRunPresetPath: options.savedRunPresetPath,
     prClassRulesWritten: options.prClassRulesWritten,
   });
 }
@@ -1359,6 +1653,9 @@ export function formatAnalyzeGithubCompletion(result) {
   if (result.savedProfilePath) {
     lines.push(`Repository profile saved: ${result.savedProfilePath}.`);
   }
+  if (result.savedRunPresetPath) {
+    lines.push(`Run preset saved: ${result.savedRunPresetPath}.`);
+  }
   if (result.prClassRulesWritten) {
     lines.push("PR class rules written: Conventional Commit preset or release title rule.");
   }
@@ -1395,26 +1692,33 @@ export async function runAnalyzeGithubCli(argv, {
   isInteractiveTerminal = Boolean(stdin?.isTTY),
 } = {}) {
   let savedProfilePath = null;
+  let savedRunPresetPath = null;
   try {
-    const options = parseAnalyzeGithubArgs(argv);
-    if (options.help) {
+    const parsedOptions = parseAnalyzeGithubArgs(argv);
+    if (parsedOptions.help) {
       stdout.write(USAGE);
       return null;
     }
+    const options = await mergeRunPresetOptions(parsedOptions);
 
+    const providedOptionKeys = new Set([
+      ...optionSourceSet(options, "explicitCliOptions"),
+      ...optionSourceSet(options, "presetOptionKeys"),
+    ]);
     const resolvedOptions = options.interactive
       ? await collectInteractiveAnalyzeGithubOptions({
         ...options,
         interactivePromptDefaults: {
-          dryRun: !options.dryRun,
-          csv: options.csv !== false,
-          json: !options.json,
+          dryRun: !providedOptionKeys.has("dryRun"),
+          csv: !providedOptionKeys.has("csv"),
+          json: !providedOptionKeys.has("json"),
         },
       }, {
         promptAdapter,
         input: stdin,
         output: stderr,
         isInteractiveTerminal,
+        promptForRunPreset: true,
         onSavedProfilePath(path) {
           savedProfilePath = path;
         },
@@ -1423,6 +1727,10 @@ export async function runAnalyzeGithubCli(argv, {
     if (resolvedOptions.savedProfilePath) {
       savedProfilePath = resolvedOptions.savedProfilePath;
     }
+    if (resolvedOptions.savePresetPath) {
+      savedRunPresetPath = await writeRunPresetFile(resolvedOptions.savePresetPath, resolvedOptions);
+      resolvedOptions.savedRunPresetPath = savedRunPresetPath;
+    }
     const runOptions = {
       onProgress: message => writeProgress(message, stderr),
     };
@@ -1436,6 +1744,9 @@ export async function runAnalyzeGithubCli(argv, {
     if (savedProfilePath) {
       stderr.write(`Repository profile saved before failure: ${savedProfilePath}.\n`);
     }
+    if (savedRunPresetPath) {
+      stderr.write(`Run preset saved before failure: ${savedRunPresetPath}.\n`);
+    }
     throw error;
   }
 }