@bigking67/pi-67 0.10.3 → 0.10.5

package/src/commands/xtalpi.mjs

@@ -6,17 +6,26 @@ import { CliError } from "../lib/output.mjs";
 
 export async function xtalpiCommand(ctx, argv) {
   const [sub = "health", ...rest] = argv;
+  if (sub === "-h" || sub === "--help" || sub === "help") {
+    printXtalpiHelp();
+    return;
+  }
   if (sub === "health") return health(ctx, rest);
   if (sub === "smoke") return smoke(ctx, rest);
   if (sub === "capability") return capability(ctx, rest);
+  if (sub === "trend") return trend(ctx, rest);
+  if (sub === "drift") return drift(ctx, rest);
+  if (sub === "stress") return stress(ctx, rest);
+  if (sub === "run") return run(ctx, rest);
   throw new CliError(`unknown xtalpi command: ${sub}`, 2);
 }
 
 function health(ctx, argv) {
   const { options } = parseCommandOptions(argv, {
     strings: ["model", "provider", "timeout-ms", "attempts"],
-    bools: ["dry-run"],
+    bools: ["dry-run", "json"],
   });
+  if (options.help) return printXtalpiHelp();
   const args = [scriptPath(ctx, "pi67-xtalpi-provider-health.mjs"), "--agent-dir", ctx.agentDir];
   if (options.provider) args.push("--provider", options.provider);
   if (options.model) args.push("--model", options.model);
@@ -30,6 +39,7 @@ function smoke(ctx, argv) {
     strings: ["case", "profile"],
     bools: ["quick", "extension-low-risk", "extension-expanded", "self-test", "dry-run"],
   });
+  if (options.help) return printXtalpiHelp();
   if (isWindows()) {
     const pwsh = findPowerShell();
     if (!pwsh) throw new CliError("PowerShell executable not found");
@@ -50,8 +60,9 @@ function smoke(ctx, argv) {
 function capability(ctx, argv) {
   const { options } = parseCommandOptions(argv, {
     strings: ["model", "provider", "timeout-ms"],
-    bools: ["dry-run", "self-test"],
+    bools: ["dry-run", "self-test", "json"],
   });
+  if (options.help) return printXtalpiHelp();
   const args = [scriptPath(ctx, "pi67-xtalpi-provider-capability-probe.mjs"), "--agent-dir", ctx.agentDir];
   if (options.selfTest) args.push("--self-test");
   if (options.provider) args.push("--provider", options.provider);
@@ -60,6 +71,87 @@ function capability(ctx, argv) {
   runCommand("node", args, { cwd: ctx.repoRoot, dryRun: ctx.dryRun || options.dryRun });
 }
 
+function trend(ctx, argv) {
+  const { options } = parseCommandOptions(argv, {
+    strings: ["limit", "profile", "out-dir"],
+    bools: ["json", "dry-run"],
+  });
+  if (options.help) return printXtalpiHelp();
+  const limit = options.limit || "3";
+  const args = [scriptPath(ctx, "pi67-xtalpi-pi-tools-debug-summary.sh"), "--trend-gate", limit];
+  if (options.profile) args.push("--profile", options.profile);
+  else args.push("--profile", "full-suite-strict");
+  if (ctx.json || options.json) args.push("--json");
+  if (options.outDir) args.push(options.outDir);
+  runCommand("bash", args, { cwd: ctx.repoRoot, dryRun: ctx.dryRun || options.dryRun });
+}
+
+function drift(ctx, argv) {
+  const { options } = parseCommandOptions(argv, {
+    strings: ["limit", "run-kind", "out-dir"],
+    bools: ["json", "dry-run"],
+  });
+  if (options.help) return printXtalpiHelp();
+  const limit = options.limit || "10";
+  const args = [scriptPath(ctx, "pi67-xtalpi-pi-tools-debug-summary.sh"), "--drift", limit];
+  args.push("--run-kind", options.runKind || "full-suite");
+  if (ctx.json || options.json) args.push("--json");
+  if (options.outDir) args.push(options.outDir);
+  runCommand("bash", args, { cwd: ctx.repoRoot, dryRun: ctx.dryRun || options.dryRun });
+}
+
+function stress(ctx, argv) {
+  const { options } = parseCommandOptions(argv, {
+    strings: ["case", "profile"],
+    bools: ["until-done", "dry-run"],
+  });
+  if (options.help) return printXtalpiHelp();
+  const smokeCase = options.untilDone ? "until-done-continuation" : options.case;
+  if (smokeCase) return smoke(ctx, ["--case", smokeCase, ...(options.dryRun ? ["--dry-run"] : [])]);
+  return smoke(ctx, ["--profile", options.profile || "full-suite", ...(options.dryRun ? ["--dry-run"] : [])]);
+}
+
+function run(ctx, argv) {
+  const passthroughIndex = argv.indexOf("--");
+  const optionArgv = passthroughIndex === -1 ? argv : argv.slice(0, passthroughIndex);
+  const passthrough = passthroughIndex === -1 ? [] : argv.slice(passthroughIndex + 1);
+  const { options, positionals } = parseCommandOptions(optionArgv, {
+    strings: ["model", "provider"],
+    bools: ["dry-run", "no-passive-observational-memory"],
+  });
+  if (options.help) return printXtalpiHelp();
+  const provider = options.provider || "xtalpi-pi-tools";
+  const model = options.model || "deepseek-v4-pro";
+  const piArgs = [...positionals, ...passthrough];
+  const env = {};
+  if (options.noPassiveObservationalMemory) {
+    env.PI_OBSERVATIONAL_MEMORY_PASSIVE = "false";
+  }
+  if (isWindows()) {
+    const pwsh = findPowerShell();
+    if (!pwsh) throw new CliError("PowerShell executable not found");
+    const args = [
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptPath(ctx, "pi67-xtalpi-pi-tools.ps1"),
+      "-Provider",
+      provider,
+      "-Model",
+      model,
+      ...piArgs,
+    ];
+    runCommand(pwsh, args, { cwd: ctx.repoRoot, dryRun: ctx.dryRun || options.dryRun, env });
+    return;
+  }
+  runCommand("bash", [scriptPath(ctx, "pi67-xtalpi-pi-tools.sh"), ...piArgs], {
+    cwd: ctx.repoRoot,
+    dryRun: ctx.dryRun || options.dryRun,
+    env: { PROVIDER: provider, MODEL: model, ...env },
+  });
+}
+
 function profileFromOptions(options) {
   if (options.profile) return options.profile;
   if (options.extensionLowRisk) return "extension-low-risk";
@@ -67,3 +159,38 @@ function profileFromOptions(options) {
   if (options.quick) return "quick";
   return "quick";
 }
+
+function printXtalpiHelp() {
+  process.stdout.write(`pi-67 xtalpi - xtalpi health, smoke, and artifact helpers
+
+Usage:
+  pi-67 xtalpi health [--provider ID] [--model NAME] [--timeout-ms N] [--attempts N]
+  pi-67 xtalpi smoke [--quick|--extension-low-risk|--extension-expanded|--profile NAME]
+  pi-67 xtalpi smoke --case NAME
+  pi-67 xtalpi capability [--self-test] [--provider ID] [--model NAME]
+  pi-67 xtalpi trend [--limit N] [--profile NAME] [--json] [--out-dir DIR]
+  pi-67 xtalpi drift [--limit N] [--run-kind LIST] [--json] [--out-dir DIR]
+  pi-67 xtalpi stress --until-done
+  pi-67 xtalpi run [--provider ID] [--model NAME] [--no-passive-observational-memory] [-- <pi args>]
+
+Notes:
+  xtalpi-pi-tools treats xtalpi as plain chat-completions transport. Pi local
+  code owns tool protocol parsing, validation, repair, retry classification,
+  tool execution, and smoke gates.
+  xtalpi run uses the stable launcher and defaults
+  PI_OBSERVATIONAL_MEMORY_PASSIVE=true so post-final background memory writes
+  cannot hold the main task lifecycle open. Pass --no-passive-observational-memory
+  only when you explicitly want pi-observational-memory to record after final.
+  xtalpi drift defaults to --run-kind full-suite so targeted one-off smoke
+  artifacts do not create expected case-set drift noise.
+
+Examples:
+  pi-67 xtalpi health
+  pi-67 xtalpi smoke --quick
+  pi-67 xtalpi smoke --case until-done-continuation
+  pi-67 xtalpi trend --json
+  pi-67 xtalpi drift --json
+  pi-67 xtalpi stress --until-done
+  pi-67 xtalpi run
+`);
+}

package/src/lib/args.mjs

@@ -6,14 +6,20 @@ const BOOL_GLOBALS = new Set(["json", "dry-run", "yes", "help", "no-remote"]);
 export function splitGlobalArgs(argv) {
   const globals = {};
   const rest = [];
+  let commandSeen = false;
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
+    if (commandSeen) {
+      rest.push(arg);
+      continue;
+    }
     if (arg === "-h") {
       globals.help = true;
       continue;
     }
     if (!arg.startsWith("--")) {
       rest.push(arg);
+      commandSeen = true;
       continue;
     }
 
@@ -48,7 +54,7 @@ export function parseCommandOptions(argv, spec = {}) {
 
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
-    if (arg === "-h") {
+    if (arg === "-h" || arg === "--help") {
       options.help = true;
       continue;
     }

package/src/lib/skill-policy.mjs

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { CliError } from "./output.mjs";
 
 export function inventorySkills(ctx) {
   const sourceRoot = path.join(ctx.repoRoot, "shared-skills");
@@ -29,17 +30,105 @@ export function inventorySkills(ctx) {
   };
 }
 
-export function syncSkills(ctx, { dryRun = false } = {}) {
+export function diffSkill(ctx, name) {
   const inventory = inventorySkills(ctx);
+  const entry = inventory.entries.find((item) => item.name === name);
+  if (!entry) {
+    throw new CliError(`unknown shared skill: ${name}`, 2);
+  }
+  const sourceFiles = fileManifest(entry.source);
+  const targetFiles = entry.targetExists ? fileManifest(entry.target) : new Map();
+  const sourceNames = new Set(sourceFiles.keys());
+  const targetNames = new Set(targetFiles.keys());
+  const added = [...sourceNames].filter((rel) => !targetNames.has(rel)).sort();
+  const removed = [...targetNames].filter((rel) => !sourceNames.has(rel)).sort();
+  const modified = [...sourceNames]
+    .filter((rel) => targetNames.has(rel) && sourceFiles.get(rel).sha256 !== targetFiles.get(rel).sha256)
+    .sort();
+  return {
+    schema: "pi67.skills-diff.v1",
+    name,
+    source: entry.source,
+    target: entry.target,
+    sourceHash: entry.sourceHash,
+    targetExists: entry.targetExists,
+    targetHash: entry.targetHash,
+    identical: entry.identical,
+    conflict: entry.conflict,
+    diff: {
+      added,
+      removed,
+      modified,
+      sourceFileCount: sourceFiles.size,
+      targetFileCount: targetFiles.size,
+    },
+  };
+}
+
+export function planSkills(ctx, { names = [] } = {}) {
+  const inventory = inventorySkills(ctx);
+  const selected = normalizeNames(names, inventory);
+  const entries = selected.length === 0
+    ? inventory.entries.filter((entry) => !entry.identical)
+    : inventory.entries.filter((entry) => selected.includes(entry.name) && !entry.identical);
+  const actions = entries.map((entry) => ({
+    name: entry.name,
+    source: entry.source,
+    target: entry.target,
+    targetExists: entry.targetExists,
+    conflict: entry.conflict,
+    action: entry.conflict ? "preserve-conflict" : "copy-missing",
+    reason: entry.conflict
+      ? "target differs; default update preserves the existing global skill"
+      : "target is missing and can be copied safely",
+  }));
+  return {
+    schema: "pi67.skills-plan.v1",
+    sourceRoot: inventory.sourceRoot,
+    skillsDir: inventory.skillsDir,
+    selected,
+    summary: inventory.summary,
+    actions,
+  };
+}
+
+export function syncSkills(ctx, { dryRun = false, names = [], yes = false } = {}) {
+  const inventory = inventorySkills(ctx);
+  const selected = normalizeNames(names, inventory);
+  const selectedSet = new Set(selected);
+  const targeted = selected.length > 0;
   const actions = [];
   fs.mkdirSync(ctx.skillsDir, { recursive: true });
   for (const entry of inventory.entries) {
+    if (targeted && !selectedSet.has(entry.name)) continue;
     if (entry.identical) {
       actions.push({ name: entry.name, action: "skip", reason: "identical" });
       continue;
     }
     if (entry.conflict) {
-      actions.push({ name: entry.name, action: "warn", reason: "target differs; preserved" });
+      if (!targeted || !yes) {
+        actions.push({
+          name: entry.name,
+          action: "warn",
+          reason: targeted
+            ? "target differs; rerun with --yes to replace this explicitly named skill after backup"
+            : "target differs; bulk conflict overwrite is intentionally blocked",
+        });
+        continue;
+      }
+      const backupDir = path.join(ctx.stateDir, "backups", `${timestamp()}-skills-sync`, entry.name);
+      actions.push({
+        name: entry.name,
+        action: dryRun ? "replace-dry-run" : "replace",
+        reason: "target differs and was explicitly named with --yes",
+        backupDir,
+      });
+      if (!dryRun) {
+        fs.mkdirSync(path.dirname(backupDir), { recursive: true, mode: 0o700 });
+        fs.cpSync(entry.target, backupDir, { recursive: true, force: true });
+        fs.rmSync(entry.target, { recursive: true, force: true });
+        fs.cpSync(entry.source, entry.target, { recursive: true, errorOnExist: true });
+      }
       continue;
     }
     actions.push({ name: entry.name, action: dryRun ? "copy-dry-run" : "copy", reason: "missing" });
@@ -47,7 +136,7 @@ export function syncSkills(ctx, { dryRun = false } = {}) {
       fs.cpSync(entry.source, entry.target, { recursive: true, errorOnExist: true });
     }
   }
-  return { ...inventory, actions };
+  return { ...inventory, selected, actions };
 }
 
 function listSkillDirs(root) {
@@ -73,6 +162,44 @@ function hashDir(root) {
   return hash.digest("hex");
 }
 
+function fileManifest(root) {
+  const result = new Map();
+  if (!fs.existsSync(root)) return result;
+  const files = [];
+  walk(root, files);
+  for (const file of files.sort()) {
+    const rel = path.relative(root, file).replace(/\\/g, "/");
+    const stat = fs.statSync(file);
+    result.set(rel, {
+      path: rel,
+      bytes: stat.size,
+      sha256: sha256File(file),
+    });
+  }
+  return result;
+}
+
+function sha256File(file) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fs.readFileSync(file));
+  return hash.digest("hex");
+}
+
+function normalizeNames(names, inventory) {
+  const selected = [...new Set((names || []).filter(Boolean).map(String))];
+  const known = new Set(inventory.entries.map((entry) => entry.name));
+  for (const name of selected) {
+    if (!known.has(name)) {
+      throw new CliError(`unknown shared skill: ${name}`, 2);
+    }
+  }
+  return selected;
+}
+
+function timestamp() {
+  return new Date().toISOString().replace(/[-:]/g, "").replace(/\..+$/, "Z");
+}
+
 function walk(dir, files) {
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     const full = path.join(dir, entry.name);

package/src/lib/update-plan.mjs

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { gitStatus, remoteHead } from "./git.mjs";
+import { gitStatus, gitText, remoteHead } from "./git.mjs";
 import { currentTheme, hasTheme, listThemes } from "./theme-policy.mjs";
 import { readJsonFileIfExists } from "./config-json.mjs";
 import { listExternal } from "./external-repos.mjs";
@@ -39,6 +39,8 @@ export async function buildUpdatePlan(ctx, options = {}) {
     currentVersion: pkg.version,
     noRemote: options.noRemote,
   });
+  const dirtyClass = classifyGitShort(git?.short || "");
+  const benignRuntime = classifyBenignRuntimeDiff(ctx, dirtyClass.preservedRuntime);
 
   const recommendations = [];
   if (managerRegistry.outdated) {
@@ -49,8 +51,13 @@ export async function buildUpdatePlan(ctx, options = {}) {
     recommendations.push("Run: pi-67 install");
   } else if (!git?.isRepo) {
     recommendations.push("Agent dir exists but is not a git checkout; inspect before installing.");
-  } else if (git.dirty) {
+  } else if (git.dirty && dirtyClass.unsafeTracked.length > 0) {
     recommendations.push("Resolve or commit local changes before pi-67 update.");
+  } else if (git.dirty && benignRuntime.benign) {
+    recommendations.push("No manual action required for benign settings runtime markers; pi-67 can preserve them during update.");
+    recommendations.push("Optional: normalize local settings runtime marker if you want a clean git status.");
+  } else if (git.dirty) {
+    recommendations.push("No manual action required for user runtime config; pi-67 backs up/restores it during update.");
   } else {
     recommendations.push("Run: pi-67 update");
   }
@@ -66,7 +73,9 @@ export async function buildUpdatePlan(ctx, options = {}) {
   const decisions = buildPlanDecisions({
     ctx,
     git,
+    benignRuntime,
     managerRegistry,
+    remote,
     manifest,
     skills,
     external,
@@ -129,6 +138,7 @@ export function buildPlanDecisions(context) {
     ...new Set([...(context.manifest.runtimeFiles?.preserve || []), ...PRESERVED_RUNTIME_FILES]),
   ];
   const dirty = classifyGitShort(context.git?.short || "");
+  const benignRuntime = context.benignRuntime || { benign: false, reasons: [] };
 
   if (context.managerRegistry.outdated) {
     actions.push({
@@ -158,16 +168,36 @@ export function buildPlanDecisions(context) {
       recovery: "commit/stash intentional changes or rerun the script-level updater with an explicit dirty override",
     });
   } else if (context.git.dirty && dirty.preservedRuntime.length > 0) {
+    const remoteStatus = classifyIncomingRemoteStatus(context.git, context.remote);
+    const preserveInPlace = remoteStatus.upToDate;
     actions.push({
       id: "user-runtime-config",
       kind: "runtime-config",
-      operation: "backup-and-restore-during-update",
-      writes: ["~/.pi/pi67/backups/<timestamp>-update"],
+      operation: preserveInPlace
+        ? "preserve-in-place-no-backup"
+        : "conditional-backup-if-incoming-update-touches-runtime-config",
+      writes: preserveInPlace
+        ? []
+        : ["~/.pi/pi67/backups/pre-update-runtime-* only if incoming update touches preserved runtime files"],
       preserves: dirty.preservedRuntime,
       risk: "low",
-      reason: "only user-owned runtime config files are dirty; update snapshots and restores them instead of overwriting",
+      reason: runtimeConfigActionReason({ benignRuntime, preserveInPlace, remoteStatus }),
+      benign: benignRuntime.benign,
+      benignReasons: benignRuntime.reasons,
+      createsNewBackup: !preserveInPlace,
+      backupCondition: preserveInPlace
+        ? "none: remote already matches the local checkout"
+        : "only when fetched incoming changes overlap preserved runtime files",
     });
-    warnings.push(`dirty user runtime config will be preserved across update: ${dirty.preservedRuntime.join(", ")}`);
+    warnings.push(
+      preserveInPlace
+        ? `dirty user runtime config will stay in place; current remote is already at the local commit: ${dirty.preservedRuntime.join(", ")}`
+        : (
+          benignRuntime.benign
+            ? `benign user runtime marker will be preserved; backup is conditional on incoming path overlap: ${dirty.preservedRuntime.join(", ")}`
+            : `dirty user runtime config will be preserved; backup is conditional on incoming path overlap: ${dirty.preservedRuntime.join(", ")}`
+        ),
+    );
   }
   if (context.git?.dirty && dirty.untracked.length > 0) {
     warnings.push(`untracked files are present and will be preserved unless Git reports a path collision: ${dirty.untracked.join(", ")}`);
@@ -272,6 +302,30 @@ export function buildPlanDecisions(context) {
   return { actions, blocked, warnings };
 }
 
+function classifyIncomingRemoteStatus(git, remote) {
+  if (remote?.skipped) return { upToDate: false, known: false, reason: "remote check skipped" };
+  if (!remote?.commit || !git?.commit) return { upToDate: false, known: false, reason: remote?.message || "remote commit unknown" };
+  const local = String(git.commit);
+  const remoteCommit = String(remote.commit);
+  return {
+    upToDate: remoteCommit.startsWith(local),
+    known: true,
+    reason: remoteCommit.startsWith(local)
+      ? "remote already matches local commit"
+      : "remote differs from local commit; updater will inspect changed paths after fetch",
+  };
+}
+
+function runtimeConfigActionReason({ benignRuntime, preserveInPlace, remoteStatus }) {
+  const prefix = benignRuntime.benign
+    ? `benign runtime marker only: ${benignRuntime.reasons.join("; ")}`
+    : "only user-owned runtime config files are dirty";
+  if (preserveInPlace) {
+    return `${prefix}; ${remoteStatus.reason}; no runtime backup is needed`;
+  }
+  return `${prefix}; updater fetches first and creates a runtime backup only if incoming changes touch these preserved files`;
+}
+
 export function classifyGitShort(short) {
   const preserved = new Set(PRESERVED_RUNTIME_FILES);
   const result = {
@@ -298,6 +352,36 @@ export function classifyGitShort(short) {
   return result;
 }
 
+export function classifyBenignRuntimeDiff(ctx, preservedRuntimePaths = []) {
+  const paths = [...new Set(preservedRuntimePaths)].sort();
+  if (paths.length !== 1 || paths[0] !== "settings.json") {
+    return { benign: false, reasons: [] };
+  }
+  const diff = gitText(ctx.repoRoot, ["diff", "--", "settings.json"]);
+  if (!diff) return { benign: false, reasons: [] };
+  const changed = diff.split(/\r?\n/).filter((line) =>
+    (line.startsWith("+") || line.startsWith("-")) &&
+    !line.startsWith("+++") &&
+    !line.startsWith("---"));
+  const meaningful = changed.filter((line) => {
+    const body = line.slice(1).trim();
+    return body !== "" && body !== "}";
+  });
+  const reasons = [];
+  const markerOnly = meaningful.length > 0 &&
+    meaningful.every((line) => /^[-+]\s*"lastChangelogVersion"\s*:/.test(line));
+  if (markerOnly) {
+    reasons.push("settings.json lastChangelogVersion runtime marker changed");
+  }
+  if (changed.some((line) => ["-", "+", "-}", "+}"].includes(line.trim()))) {
+    reasons.push("settings.json trailing newline state changed");
+  }
+  return {
+    benign: markerOnly || (meaningful.length === 0 && reasons.length > 0),
+    reasons,
+  };
+}
+
 function parseStatusPath(line) {
   let file = "";
   if (line.length >= 3 && line[2] === " ") {

package/src/lib/update-safety.mjs

@@ -18,16 +18,21 @@ const LOCK_STALE_AFTER_MS = 4 * 60 * 60 * 1000;
 export function beginUpdateLifecycle(ctx, options = {}) {
   const operation = options.operation || "update";
   const dryRun = Boolean(options.dryRun);
+  const backupRuntime = options.backupRuntime !== false;
   const lockPath = path.join(ctx.stateDir, "locks", "update.lock");
   const backupDir = path.join(ctx.stateDir, "backups", `${timestamp()}-${operation}`);
 
   if (dryRun) {
     info(`DRY-RUN would acquire update lock: ${lockPath}`);
-    info(`DRY-RUN would snapshot preserved runtime files into: ${backupDir}`);
+    if (backupRuntime) {
+      info(`DRY-RUN would snapshot preserved runtime files into: ${backupDir}`);
+    }
     return {
       lockPath,
       backupDir,
       backedUp: [],
+      backupSkipped: !backupRuntime,
+      backupReason: backupRuntime ? "" : "runtime backup is delegated to the updater script when needed",
       release() {},
     };
   }
@@ -35,6 +40,21 @@ export function beginUpdateLifecycle(ctx, options = {}) {
   acquireLock(lockPath, { operation });
   let released = false;
   try {
+    if (!backupRuntime) {
+      return {
+        lockPath,
+        backupDir: "",
+        backedUp: [],
+        backupSkipped: true,
+        backupReason: "runtime backup is delegated to the updater script when needed",
+        reusedBackupDir: "",
+        release() {
+          if (released) return;
+          released = true;
+          releaseLock(lockPath);
+        },
+      };
+    }
     const backup = createRuntimeBackup(ctx, backupDir, {
       operation,
       plan: options.plan,