@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/operations/services/repository-save-orchestrator.js

@@ -1,2110 +0,0 @@
-import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { basename, resolve, relative } from "node:path";
-import { spawn, spawnSync } from "node:child_process";
-import { tmpdir } from "node:os";
-import { classifyTreeseedGitMode, runTreeseedGitText } from "./git-runner.js";
-import {
-  ensureSshPushUrlForOrigin,
-  remoteWriteUrl,
-  sshPushUrlForRemote
-} from "./git-remote-policy.js";
-import {
-  generateRepositoryCommitMessage
-} from "./commit-message-provider.js";
-import {
-  createPackageDependencyReference,
-  normalizeGitRemoteForDependency,
-  updateInternalDependencySpecs
-} from "./package-reference-policy.js";
-import {
-  PRODUCTION_BRANCH,
-  branchExists,
-  headCommit,
-  remoteBranchExists,
-  STAGING_BRANCH
-} from "./git-workflow.js";
-import {
-  collectMergeConflictReport,
-  currentBranch,
-  formatMergeConflictReport,
-  hasMeaningfulChanges,
-  incrementVersion,
-  originRemoteUrl,
-  repoRoot
-} from "./workspace-save.js";
-import {
-  hasCompleteTreeseedPackageCheckout,
-  sortWorkspacePackages,
-  workspacePackages
-} from "./workspace-tools.js";
-import { collectDeploymentLockfileWorkspaceIssues, ensureLocalWorkspaceLinks } from "./workspace-dependency-mode.js";
-import {
-  createBuildWarningSummary,
-  formatAllowedBuildWarnings
-} from "./build-warning-policy.js";
-import {
-  readTreeseedVerificationCache,
-  writeTreeseedVerificationCache
-} from "./verification-cache.js";
-import {
-  discoverTreeseedPackageAdapters
-} from "./package-adapters.js";
-import {
-  discoverTreeseedManagedRepositories,
-  parseGitmodulesPaths,
-  readTreeseedTemplateRepositoryManifest
-} from "./managed-repositories.js";
-function runGit(args, options) {
-  return runTreeseedGitText(args, {
-    cwd: options.cwd,
-    mode: classifyTreeseedGitMode(args),
-    timeoutMs: options.timeoutMs,
-    maxBuffer: options.maxBuffer
-  });
-}
-function sleepMs(durationMs) {
-  return new Promise((resolvePromise) => {
-    setTimeout(resolvePromise, durationMs);
-  });
-}
-class RepositorySaveError extends Error {
-  exitCode;
-  details;
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "RepositorySaveError";
-    this.exitCode = options.exitCode;
-    this.details = options.details;
-  }
-}
-function readJson(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"));
-}
-function writeJson(filePath, value) {
-  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function progressPrefix(node, phase) {
-  return `[${node.name}][${phase}]`;
-}
-function emitProgress(options, node, phase, message, stream = "stdout") {
-  const lines = String(message ?? "").split(/\r?\n/u).map((line) => line.trimEnd()).filter(Boolean);
-  for (const line of lines) {
-    options.onProgress?.(`${progressPrefix(node, phase)} ${line}`, stream);
-  }
-}
-function prefixedOutput(node, phase, output) {
-  return String(output ?? "").split(/\r?\n/u).map((line) => line.trimEnd()).filter(Boolean).map((line) => `${progressPrefix(node, phase)} ${line}`).join("\n");
-}
-function withShortProcessTempEnv(env = {}) {
-  const merged = { ...process.env, ...env };
-  if (process.platform === "win32") {
-    return merged;
-  }
-  const shortTemp = tmpdir();
-  const tempKeys = ["TMPDIR", "TMP", "TEMP"];
-  for (const key of tempKeys) {
-    const value = merged[key];
-    if (value && value.length > shortTemp.length) {
-      merged[key] = shortTemp;
-    }
-  }
-  return merged;
-}
-function npmCacheForCwd(cwd) {
-  const cacheDir = resolve(cwd, ".treeseed", "cache", "npm");
-  mkdirSync(cacheDir, { recursive: true });
-  return cacheDir;
-}
-function npmWorkflowEnv(env = {}, cwd = process.cwd()) {
-  const npmCache = env.npm_config_cache ?? env.NPM_CONFIG_CACHE ?? npmCacheForCwd(cwd);
-  return withShortProcessTempEnv({
-    ...env,
-    NPM_CONFIG_CACHE: npmCache,
-    npm_config_audit: env.npm_config_audit ?? process.env.npm_config_audit ?? "false",
-    npm_config_cache: npmCache,
-    npm_config_fetch_retries: env.npm_config_fetch_retries ?? process.env.npm_config_fetch_retries ?? "2",
-    npm_config_fund: env.npm_config_fund ?? process.env.npm_config_fund ?? "false",
-    npm_config_foreground_scripts: env.npm_config_foreground_scripts ?? process.env.npm_config_foreground_scripts ?? "true",
-    npm_config_loglevel: env.npm_config_loglevel ?? process.env.npm_config_loglevel ?? "warn",
-    npm_config_maxsockets: env.npm_config_maxsockets ?? process.env.npm_config_maxsockets ?? "4",
-    npm_config_prefer_offline: env.npm_config_prefer_offline ?? process.env.npm_config_prefer_offline ?? "true",
-    npm_config_progress: env.npm_config_progress ?? process.env.npm_config_progress ?? "false"
-  });
-}
-function npmCommandForSpawn(args) {
-  if (process.platform === "win32") {
-    return { command: "npm", args };
-  }
-  return {
-    command: "bash",
-    args: [
-      "-lc",
-      'ulimit -n 65535 2>/dev/null || ulimit -n 32768 2>/dev/null || ulimit -n 16384 2>/dev/null || true; exec npm "$@"',
-      "npm-fd-guard",
-      ...args
-    ]
-  };
-}
-function displayCommand(command, args) {
-  return command === "npm" ? `npm ${args.join(" ")}` : `${command} ${args.join(" ")}`;
-}
-function runCapturedCommand(node, options, phase, command, args, commandOptions = {}) {
-  const cwd = commandOptions.cwd ?? node.path;
-  const spawnCommand = command === "npm" ? npmCommandForSpawn(args) : { command, args };
-  emitProgress(options, node, phase, `$ ${displayCommand(command, args)}`);
-  const result = spawnSync(spawnCommand.command, spawnCommand.args, {
-    cwd,
-    env: command === "npm" ? npmWorkflowEnv(commandOptions.env, cwd) : withShortProcessTempEnv(commandOptions.env),
-    stdio: "pipe",
-    encoding: "utf8",
-    timeout: commandOptions.timeoutMs
-  });
-  const stdout = result.stdout?.trim() ?? "";
-  const stderr = result.stderr?.trim() ?? "";
-  if (commandOptions.emitOutputOnSuccess !== false) {
-    if (stdout) emitProgress(options, node, phase, stdout);
-    if (stderr) emitProgress(options, node, phase, stderr, "stderr");
-  }
-  if (result.status !== 0) {
-    const message = (result.error?.message ? `${result.error.message}
-` : "") + (prefixedOutput(node, phase, stderr) || prefixedOutput(node, phase, stdout) || `${progressPrefix(node, phase)} ${displayCommand(command, args)} failed`);
-    throw new RepositorySaveError(message, {
-      details: {
-        failingRepo: node.name,
-        phase,
-        command: displayCommand(command, args)
-      }
-    });
-  }
-  return stdout;
-}
-function npmLockfilePackageCount(repoDir) {
-  try {
-    const lockfile = readJson(resolve(repoDir, "package-lock.json"));
-    const packages = lockfile.packages;
-    if (packages && typeof packages === "object" && !Array.isArray(packages)) {
-      return Math.max(0, Object.keys(packages).filter((entry) => entry !== "").length);
-    }
-    const dependencies = lockfile.dependencies;
-    if (dependencies && typeof dependencies === "object" && !Array.isArray(dependencies)) {
-      return Object.keys(dependencies).length;
-    }
-  } catch {
-  }
-  return null;
-}
-function isNoOpGitCommitError(error) {
-  if (!(error instanceof RepositorySaveError)) return false;
-  const command = typeof error.details?.command === "string" ? error.details.command : "";
-  if (!command.startsWith("git commit ")) return false;
-  return /nothing to commit|no changes added to commit/u.test(error.message);
-}
-function runQuietCommand(node, phase, command, args, commandOptions = {}) {
-  const cwd = commandOptions.cwd ?? node.path;
-  const spawnCommand = command === "npm" ? npmCommandForSpawn(args) : { command, args };
-  const result = spawnSync(spawnCommand.command, spawnCommand.args, {
-    cwd,
-    env: command === "npm" ? npmWorkflowEnv(commandOptions.env, cwd) : withShortProcessTempEnv(commandOptions.env),
-    stdio: "pipe",
-    encoding: "utf8",
-    timeout: commandOptions.timeoutMs
-  });
-  const stdout = result.stdout?.trim() ?? "";
-  const stderr = result.stderr?.trim() ?? "";
-  if (result.status !== 0) {
-    throw new RepositorySaveError(
-      [
-        `${progressPrefix(node, phase)} ${displayCommand(command, args)} failed`,
-        stderr || stdout
-      ].filter(Boolean).join("\n"),
-      {
-        details: {
-          failingRepo: node.name,
-          phase,
-          command: displayCommand(command, args)
-        }
-      }
-    );
-  }
-  return stdout;
-}
-async function runStreamingCommand(node, options, phase, command, args, commandOptions = {}) {
-  const cwd = commandOptions.cwd ?? node.path;
-  const spawnCommand = command === "npm" ? npmCommandForSpawn(args) : { command, args };
-  emitProgress(options, node, phase, `$ ${displayCommand(command, args)}`);
-  return await new Promise((resolvePromise, reject) => {
-    const child = spawn(spawnCommand.command, spawnCommand.args, {
-      cwd,
-      env: command === "npm" ? npmWorkflowEnv(commandOptions.env, cwd) : withShortProcessTempEnv(commandOptions.env),
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let stdoutRemainder = "";
-    let stderrRemainder = "";
-    let settled = false;
-    const warningSummary = commandOptions.buildWarningPolicy === false ? null : createBuildWarningSummary();
-    const flush = (chunk, stream) => {
-      const combined = stream === "stdout" ? stdoutRemainder + chunk : stderrRemainder + chunk;
-      const parts = combined.split(/\r?\n/u);
-      const complete = parts.slice(0, -1);
-      if (stream === "stdout") stdoutRemainder = parts.at(-1) ?? "";
-      else stderrRemainder = parts.at(-1) ?? "";
-      for (const line of complete) {
-        const classified = warningSummary?.record(line, commandOptions.buildWarningPolicy || void 0);
-        if (classified?.kind === "allowed") {
-          continue;
-        }
-        emitProgress(options, node, phase, line, stream);
-      }
-    };
-    const timeout = commandOptions.timeoutMs ? setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      child.kill("SIGTERM");
-      reject(new Error(`${progressPrefix(node, phase)} ${displayCommand(command, args)} timed out after ${commandOptions.timeoutMs}ms`));
-    }, commandOptions.timeoutMs) : null;
-    child.stdout?.on("data", (chunk) => {
-      const text = chunk.toString();
-      stdout += text;
-      flush(text, "stdout");
-    });
-    child.stderr?.on("data", (chunk) => {
-      const text = chunk.toString();
-      stderr += text;
-      flush(text, "stderr");
-    });
-    child.on("error", (error) => {
-      if (settled) return;
-      settled = true;
-      if (timeout) clearTimeout(timeout);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (settled) return;
-      settled = true;
-      if (timeout) clearTimeout(timeout);
-      if (stdoutRemainder) {
-        const classified = warningSummary?.record(stdoutRemainder, commandOptions.buildWarningPolicy || void 0);
-        if (classified?.kind !== "allowed") emitProgress(options, node, phase, stdoutRemainder);
-      }
-      if (stderrRemainder) {
-        const classified = warningSummary?.record(stderrRemainder, commandOptions.buildWarningPolicy || void 0);
-        if (classified?.kind !== "allowed") emitProgress(options, node, phase, stderrRemainder, "stderr");
-      }
-      if (code === 0) {
-        if (warningSummary) {
-          for (const line of formatAllowedBuildWarnings(warningSummary.allowedWarnings)) {
-            emitProgress(options, node, phase, line);
-          }
-        }
-        resolvePromise({ stdout, stderr });
-        return;
-      }
-      reject(new RepositorySaveError(
-        prefixedOutput(node, phase, stderr) || prefixedOutput(node, phase, stdout) || `${progressPrefix(node, phase)} ${displayCommand(command, args)} failed with exit code ${code ?? "unknown"}`,
-        {
-          details: {
-            failingRepo: node.name,
-            phase,
-            command: displayCommand(command, args)
-          }
-        }
-      ));
-    });
-  });
-}
-function packageScripts(packageJson) {
-  const scripts = packageJson?.scripts;
-  return scripts && typeof scripts === "object" && !Array.isArray(scripts) ? Object.fromEntries(Object.entries(scripts).map(([key, value]) => [key, String(value)])) : {};
-}
-function classifyRepoKind(packageJson, managedKind) {
-  if (managedKind === "template") return "template";
-  if (managedKind === "fixture") return "fixture";
-  if (typeof packageJson?.name !== "string" || typeof packageJson?.version !== "string") {
-    return "project";
-  }
-  if (packageJson.private === true) {
-    return "project";
-  }
-  const scripts = packageScripts(packageJson);
-  const publishConfig = packageJson.publishConfig;
-  return typeof scripts["release:publish"] === "string" || publishConfig !== null && typeof publishConfig === "object" && !Array.isArray(publishConfig) ? "package" : "project";
-}
-function dependencyFields(packageJson) {
-  if (!packageJson) return [];
-  return ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"].filter((field) => packageJson[field] && typeof packageJson[field] === "object" && !Array.isArray(packageJson[field]));
-}
-function repoIdForPath(root, repoDir) {
-  return relative(root, repoDir).replaceAll("\\", "/") || ".";
-}
-function isGitRepo(repoDir) {
-  try {
-    runGit(["rev-parse", "--is-inside-work-tree"], { cwd: repoDir, capture: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isIndependentGitRepo(repoDir) {
-  try {
-    return resolve(repoRoot(repoDir)) === resolve(repoDir);
-  } catch {
-    return false;
-  }
-}
-function originRemoteUrlSafe(repoDir) {
-  try {
-    return originRemoteUrl(repoDir);
-  } catch {
-    return null;
-  }
-}
-function ensureWritableRemote(node, options) {
-  if (!node.remoteUrl || (options.gitRemoteWriteMode ?? "ssh-pushurl") === "off") return;
-  const result = ensureSshPushUrlForOrigin(node.path, node.remoteUrl, options.gitRemoteWriteMode ?? "ssh-pushurl");
-  if (result.changed && result.pushUrl) {
-    emitProgress(options, node, "remote", `Configured origin push URL ${result.pushUrl}; keeping ${node.remoteUrl} for reads.`);
-  }
-}
-function repoDisplayName(repoDir, packageJson) {
-  return typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : basename(repoDir);
-}
-function emptyManifestVerifyCommands() {
-  return { fast: null, local: null, release: null };
-}
-function verifyCommandFromString(repoDir, label, command) {
-  return command ? { label, command: "bash", args: ["-lc", command], cwd: repoDir } : null;
-}
-function templateVerifyCommands(repoDir) {
-  const manifest = readTreeseedTemplateRepositoryManifest(repoDir);
-  if (!manifest) return null;
-  return {
-    fast: verifyCommandFromString(repoDir, "fast", manifest.verify.fast),
-    local: verifyCommandFromString(repoDir, "local", manifest.verify.local),
-    release: verifyCommandFromString(repoDir, "release", manifest.verify.release)
-  };
-}
-function parseGitmodules(root) {
-  return parseGitmodulesPaths(root);
-}
-function slugBranch(branch) {
-  return branch.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "dev";
-}
-function timestampLabel(date = /* @__PURE__ */ new Date()) {
-  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/u, "Z");
-}
-function nextDevVersion(version, branch, date = /* @__PURE__ */ new Date()) {
-  return `${incrementVersion(version, "patch")}-dev.${slugBranch(branch)}.${timestampLabel(date)}`;
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function isStableSemverVersion(version) {
-  return /^\d+\.\d+\.\d+$/u.test(version);
-}
-function isDevVersionForBranch(version, branch) {
-  const branchSlug = escapeRegExp(slugBranch(branch));
-  return new RegExp(`^\\d+\\.\\d+\\.\\d+-dev\\.${branchSlug}\\.\\d{8}T\\d{6}Z$`, "u").test(version);
-}
-function packageVersionAtHead(node) {
-  if (!node.packageJsonPath) return null;
-  try {
-    const source = runGit(["show", "HEAD:package.json"], { cwd: node.path, capture: true });
-    const packageJson = JSON.parse(source);
-    return typeof packageJson.version === "string" ? packageJson.version : null;
-  } catch {
-    return null;
-  }
-}
-function headCommitOrPlanPlaceholder(cwd) {
-  try {
-    return headCommit(cwd);
-  } catch {
-    return "HEAD";
-  }
-}
-function remoteBranchCommitSafe(cwd, branch) {
-  try {
-    const output = runGit(["ls-remote", "origin", `refs/heads/${branch}`], { cwd, capture: true });
-    const [sha] = output.trim().split(/\s+/u);
-    return /^[a-f0-9]{40}$/u.test(sha ?? "") ? sha : null;
-  } catch {
-    return null;
-  }
-}
-function canManagePackageJsonVersion(node) {
-  return node.kind === "package" && Boolean(node.packageJsonPath) && typeof node.packageJson?.version === "string";
-}
-function packageVersionEligibleForBranch(node, version, options) {
-  return node.branchMode === "package-release-main" ? isStableSemverVersion(version) : isDevVersionForBranch(version, node.branch || options.branch);
-}
-function packageVersionTagConflictsWithHead(node, options) {
-  if (node.kind !== "package") return false;
-  if (node.branchMode === "package-dev-save" && (options.devDependencyReferenceMode ?? "git-commit") === "git-commit") return false;
-  const version = typeof node.packageJson?.version === "string" ? node.packageJson.version : null;
-  if (!version || !packageVersionEligibleForBranch(node, version, options)) return false;
-  const head = headCommit(node.path);
-  const state = tagState(node.path, version);
-  return state.localCommit != null && state.localCommit !== head || state.remoteCommit != null && state.remoteCommit !== head;
-}
-function selectPackageVersion(node, options) {
-  const current = String(node.packageJson?.version ?? "0.0.0");
-  if (node.branchMode === "package-dev-save" && isDevVersionForBranch(current, node.branch || options.branch) && ((options.devDependencyReferenceMode ?? "git-commit") === "git-commit" || !tagExists(node.path, current))) {
-    return { version: current, reused: true };
-  }
-  if (node.branchMode === "package-release-main") {
-    const headVersion = packageVersionAtHead(node);
-    if (headVersion && current === incrementVersion(headVersion, options.bump ?? "patch") && !tagExists(node.path, current)) {
-      return { version: current, reused: true };
-    }
-  }
-  return { version: planPackageVersion(node, options), reused: false };
-}
-function createReport(node) {
-  return {
-    name: node.name,
-    path: node.path,
-    branch: node.branch,
-    dirty: hasMeaningfulChanges(node.path),
-    created: false,
-    resumed: false,
-    merged: false,
-    verified: false,
-    committed: false,
-    pushed: false,
-    deletedLocal: false,
-    deletedRemote: false,
-    tagName: null,
-    commitSha: node.branch ? headCommit(node.path) : null,
-    skippedReason: null,
-    publishWait: null,
-    version: typeof node.packageJson?.version === "string" ? node.packageJson.version : null,
-    dependencySpec: node.plannedDependencySpec,
-    branchMode: node.branchMode,
-    verification: null,
-    install: null,
-    lockfileValidation: null,
-    commitMessage: null,
-    commitMessageProvider: null,
-    commitMessageFallbackUsed: false,
-    commitMessageError: null
-  };
-}
-function discoverRepositorySaveNodes(root, gitRoot = repoRoot(root), branch = currentBranch(gitRoot), options = {}) {
-  const repoDirs = /* @__PURE__ */ new Map();
-  const packageAdaptersByDir = new Map(discoverTreeseedPackageAdapters(root).map((adapter) => [resolve(adapter.dir), adapter]));
-  const managedRepositoriesByDir = new Map(discoverTreeseedManagedRepositories(root).map((repo) => [resolve(repo.dir), repo]));
-  for (const repo of managedRepositoriesByDir.values()) {
-    repoDirs.set(repo.relativeDir, repo.dir);
-  }
-  if (!repoDirs.has(".")) {
-    repoDirs.set(".", gitRoot);
-  }
-  if (hasCompleteTreeseedPackageCheckout(root)) {
-    for (const pkg of workspacePackages(root)) {
-      if (isIndependentGitRepo(pkg.dir)) {
-        repoDirs.set(pkg.relativeDir, pkg.dir);
-      }
-    }
-  }
-  for (const adapter of packageAdaptersByDir.values()) {
-    if (isIndependentGitRepo(adapter.dir)) {
-      repoDirs.set(adapter.relativeDir, adapter.dir);
-    }
-  }
-  for (const submodulePath of parseGitmodules(root)) {
-    const dir = resolve(root, submodulePath);
-    if (existsSync(dir) && isIndependentGitRepo(dir)) {
-      repoDirs.set(submodulePath, dir);
-    }
-  }
-  const nodes = [...repoDirs.entries()].map(([relativePath, repoDir]) => {
-    const packageJsonPath = resolve(repoDir, "package.json");
-    const packageJson = existsSync(packageJsonPath) ? readJson(packageJsonPath) : null;
-    const adapter = packageAdaptersByDir.get(resolve(repoDir)) ?? null;
-    const managed = managedRepositoriesByDir.get(resolve(repoDir)) ?? null;
-    const kind = adapter && !packageJson ? "package" : classifyRepoKind(packageJson, managed?.kind);
-    const repoBranch = relativePath === "." ? currentBranch(repoDir) || branch || null : branch || currentBranch(repoDir) || null;
-    const branchMode = kind === "project" ? "project-save" : options.stablePackageRelease === true && repoBranch === PRODUCTION_BRANCH ? "package-release-main" : "package-dev-save";
-    return {
-      id: relativePath,
-      name: managed?.kind === "template" || managed?.kind === "fixture" ? managed.name : adapter?.id ?? repoDisplayName(repoDir, packageJson),
-      path: repoDir,
-      relativePath,
-      kind,
-      branch: repoBranch,
-      branchMode,
-      packageJsonPath: packageJson ? packageJsonPath : null,
-      packageJson,
-      scripts: packageScripts(packageJson),
-      manifestVerifyCommands: adapter?.verifyCommands ?? templateVerifyCommands(repoDir) ?? emptyManifestVerifyCommands(),
-      remoteUrl: originRemoteUrlSafe(repoDir),
-      dependencies: [],
-      dependents: [],
-      submoduleDependencies: [],
-      plannedVersion: null,
-      plannedTag: null,
-      plannedDependencySpec: null
-    };
-  });
-  return deriveRepositoryGraph(root, nodes);
-}
-function deriveRepositoryGraph(root, nodes) {
-  const byPackageName = new Map(nodes.filter((node) => node.kind === "package").map((node) => [String(node.packageJson?.name), node]));
-  const byId = new Map(nodes.map((node) => [node.id, node]));
-  const dependencies = new Map(nodes.map((node) => [node.id, /* @__PURE__ */ new Set()]));
-  const dependents = new Map(nodes.map((node) => [node.id, /* @__PURE__ */ new Set()]));
-  for (const node of nodes) {
-    for (const field of dependencyFields(node.packageJson)) {
-      const values = node.packageJson?.[field];
-      for (const depName of Object.keys(values)) {
-        const dependency = byPackageName.get(depName);
-        if (!dependency || dependency.id === node.id) continue;
-        dependencies.get(node.id)?.add(dependency.id);
-        dependents.get(dependency.id)?.add(node.id);
-      }
-    }
-    for (const submodulePath of parseGitmodules(node.path)) {
-      const absolute = resolve(node.path, submodulePath);
-      const relativeToRoot = repoIdForPath(root, absolute);
-      const dependency = byId.get(relativeToRoot);
-      if (!dependency || dependency.id === node.id) continue;
-      dependencies.get(node.id)?.add(dependency.id);
-      dependents.get(dependency.id)?.add(node.id);
-    }
-  }
-  return nodes.map((node) => ({
-    ...node,
-    dependencies: [...dependencies.get(node.id) ?? []].sort(),
-    dependents: [...dependents.get(node.id) ?? []].sort(),
-    submoduleDependencies: [...dependencies.get(node.id) ?? []].filter((id) => node.id === "." || id.startsWith(`${node.id}/`)).sort()
-  }));
-}
-function repositorySaveWaves(nodes) {
-  const nodeIds = new Set(nodes.map((node) => node.id));
-  const dependencies = new Map(nodes.map((node) => [node.id, new Set(node.dependencies.filter((id) => nodeIds.has(id)))]));
-  const dependents = new Map(nodes.map((node) => [node.id, new Set(node.dependents.filter((id) => nodeIds.has(id)))]));
-  const ready = [...nodes].filter((node) => (dependencies.get(node.id)?.size ?? 0) === 0).sort(compareNodes);
-  const waves = [];
-  const processed = /* @__PURE__ */ new Set();
-  while (ready.length > 0) {
-    const wave = ready.splice(0).filter((node) => !processed.has(node.id));
-    if (wave.length === 0) continue;
-    waves.push(wave);
-    for (const node of wave) {
-      processed.add(node.id);
-      for (const dependentId of dependents.get(node.id) ?? []) {
-        const remaining = dependencies.get(dependentId);
-        remaining?.delete(node.id);
-        if (remaining && remaining.size === 0 && !processed.has(dependentId)) {
-          const dependent = nodes.find((candidate) => candidate.id === dependentId);
-          if (dependent) ready.push(dependent);
-        }
-      }
-    }
-    ready.sort(compareNodes);
-  }
-  if (processed.size !== nodes.length) {
-    const unresolved = nodes.filter((node) => !processed.has(node.id)).map((node) => `${node.name} depends on ${(dependencies.get(node.id) ? [...dependencies.get(node.id)] : []).join(", ")}`);
-    throw new RepositorySaveError(`Repository dependency cycle detected:
-${unresolved.join("\n")}`, {
-      details: { unresolved }
-    });
-  }
-  return waves;
-}
-function compareNodes(left, right) {
-  if (left.id === ".") return 1;
-  if (right.id === ".") return -1;
-  const sorted = sortWorkspacePackages([
-    { name: left.name, relativeDir: left.relativePath, dir: left.path, packageJson: left.packageJson ?? {} },
-    { name: right.name, relativeDir: right.relativePath, dir: right.path, packageJson: right.packageJson ?? {} }
-  ]);
-  return sorted[0]?.name === left.name ? -1 : 1;
-}
-function runLimited(items, limit, action) {
-  let index = 0;
-  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (index < items.length) {
-      const current = items[index++];
-      await action(current);
-    }
-  });
-  return Promise.all(workers);
-}
-function repositorySaveConcurrency(options) {
-  if (options.verifyMode && options.verifyMode !== "skip") {
-    return 1;
-  }
-  const configured = Number.parseInt(process.env.TREESEED_SAVE_REPOSITORY_CONCURRENCY ?? "", 10);
-  return Number.isFinite(configured) && configured > 0 ? configured : 3;
-}
-function remoteBranchExistsSafe(repoDir, branch) {
-  try {
-    runGit(["rev-parse", "--verify", `refs/remotes/origin/${branch}`], { cwd: repoDir, capture: true });
-    return true;
-  } catch {
-  }
-  try {
-    return remoteBranchExists(repoDir, branch);
-  } catch {
-    return false;
-  }
-}
-function checkoutCommandFor(repoDir, branch) {
-  if (currentBranch(repoDir) === branch) return `git checkout ${branch} # already current`;
-  if (branchExists(repoDir, branch)) return `git checkout ${branch}`;
-  if (remoteBranchExistsSafe(repoDir, branch)) return `git checkout -b ${branch} origin/${branch}`;
-  return `git checkout -b ${branch}`;
-}
-function checkoutOrCreateBranch(node, options, branch) {
-  if (currentBranch(node.path) === branch) {
-    emitProgress(options, node, "branch", `Already on ${branch}.`);
-    return;
-  }
-  if (branchExists(node.path, branch)) {
-    runCapturedCommand(node, options, "branch", "git", ["checkout", branch]);
-    return;
-  }
-  if (remoteBranchExistsSafe(node.path, branch)) {
-    runCapturedCommand(node, options, "branch", "git", ["checkout", "-b", branch, `origin/${branch}`]);
-    return;
-  }
-  runCapturedCommand(node, options, "branch", "git", ["checkout", "-b", branch]);
-}
-async function commitMessageFor(node, options, context) {
-  return generateRepositoryCommitMessage({
-    repoName: node.name,
-    repoPath: node.path,
-    branch: node.branch || options.branch,
-    kind: node.kind,
-    branchMode: node.branchMode,
-    userMessage: options.message?.trim() || void 0,
-    ...context
-  }, {
-    mode: options.commitMessageMode ?? "auto",
-    provider: options.commitMessageProvider
-  });
-}
-function commitSubject(message) {
-  return String(message ?? "").split(/\r?\n/u)[0]?.trim() || null;
-}
-function gitDiffSummary(repoDir) {
-  const changedFiles = runGit(["status", "--porcelain"], { cwd: repoDir, capture: true });
-  const rawDiff = runGit(["diff", "--cached"], { cwd: repoDir, capture: true, maxBuffer: 1024 * 1024 * 32 });
-  const maxDiffChars = 12e4;
-  const diff = rawDiff.length > maxDiffChars ? `${rawDiff.slice(0, maxDiffChars)}
-
-[treeseed-save: diff truncated from ${rawDiff.length} characters for commit-message generation]
-` : rawDiff;
-  return { changedFiles, diff };
-}
-function hasStagedChanges(repoDir) {
-  try {
-    return runGit(["diff", "--cached", "--name-only"], { cwd: repoDir, capture: true }).trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-function updateDependencyReferences(node, finalizedReferences) {
-  if (!node.packageJson || !node.packageJsonPath) return [];
-  const changed = updateInternalDependencySpecs(node.packageJson, finalizedReferences);
-  if (changed.length > 0) {
-    writeJson(node.packageJsonPath, node.packageJson);
-  }
-  return changed;
-}
-function isRootWorkspaceRepository(node, options) {
-  const packageJson = node.packageJson ?? (existsSync(resolve(node.path, "package.json")) ? readJson(resolve(node.path, "package.json")) : null);
-  return node.path === options.root && Array.isArray(packageJson?.workspaces);
-}
-function syncDirectGitDependencyLockfileEntries(node, options, references) {
-  if (references.length === 0) return false;
-  const lockfilePath = resolve(node.path, "package-lock.json");
-  if (!existsSync(lockfilePath)) return false;
-  const lockfile = readJson(lockfilePath);
-  const rootPackage = lockfile.packages && typeof lockfile.packages === "object" && !Array.isArray(lockfile.packages) ? lockfile.packages[""] : null;
-  const packageEntries = lockfile.packages && typeof lockfile.packages === "object" && !Array.isArray(lockfile.packages) ? lockfile.packages : null;
-  if (!rootPackage || !packageEntries) return false;
-  let changed = false;
-  for (const reference of references) {
-    const manifestSpec = reference.manifestSpec ?? reference.spec;
-    const declaredSpec = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"].map((field) => node.packageJson?.[field]).filter((value) => Boolean(value && typeof value === "object" && !Array.isArray(value))).map((dependencies) => dependencies[reference.packageName]).find((value) => typeof value === "string");
-    if (declaredSpec !== manifestSpec) continue;
-    const visitDependencyMaps = (value) => {
-      if (!value || typeof value !== "object") return;
-      if (Array.isArray(value)) {
-        for (const item of value) visitDependencyMaps(item);
-        return;
-      }
-      const record = value;
-      for (const field of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
-        const dependencies = record[field];
-        if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) continue;
-        const dependencyMap = dependencies;
-        const current = dependencyMap[reference.packageName];
-        if (typeof current === "string" && current !== manifestSpec) {
-          dependencyMap[reference.packageName] = manifestSpec;
-          changed = true;
-        }
-      }
-      for (const nested of Object.values(record)) visitDependencyMaps(nested);
-    };
-    visitDependencyMaps(lockfile);
-    for (const [entryKey, entry] of Object.entries(packageEntries)) {
-      if (entryKey !== `node_modules/${reference.packageName}` && !entryKey.endsWith(`/node_modules/${reference.packageName}`)) continue;
-      const nextResolved = normalizeGitRemoteForDependency(reference.remoteUrl ?? "", "ssh");
-      const resolved = nextResolved ? `${nextResolved}#${manifestSpec.slice(manifestSpec.lastIndexOf("#") + 1)}` : manifestSpec;
-      if (entry.resolved !== resolved) {
-        entry.resolved = resolved;
-        changed = true;
-      }
-      if (typeof reference.version === "string" && reference.version && entry.version !== reference.version) {
-        entry.version = reference.version;
-        changed = true;
-      }
-      if ("integrity" in entry) {
-        delete entry.integrity;
-        changed = true;
-      }
-    }
-  }
-  if (!changed) return false;
-  writeJson(lockfilePath, lockfile);
-  emitProgress(options, node, "lockfile", "Synchronized direct internal Git dependency lockfile entries without npm git preparation.");
-  return true;
-}
-function validateStandaloneGitDependencyLockfile(node, options) {
-  const lockfilePath = resolve(node.path, "package-lock.json");
-  const lockfileExists = existsSync(lockfilePath);
-  const previousLockfile = lockfileExists ? readFileSync(lockfilePath, "utf8") : null;
-  const isolatedRoot = mkdtempSync(resolve(tmpdir(), "treeseed-lockfile-"));
-  const validateArgs = [
-    "ci",
-    "--package-lock-only",
-    "--ignore-scripts",
-    "--workspaces=false",
-    "--no-audit",
-    "--no-fund"
-  ];
-  try {
-    if (!lockfileExists) throw new Error("standalone lockfile missing");
-    copyFileSync(resolve(node.path, "package.json"), resolve(isolatedRoot, "package.json"));
-    copyFileSync(lockfilePath, resolve(isolatedRoot, "package-lock.json"));
-    runCapturedCommand(node, options, "lockfile", "npm", validateArgs, {
-      cwd: isolatedRoot,
-      timeoutMs: 5 * 6e4
-    });
-  } catch (validationError) {
-    try {
-      rmSync(isolatedRoot, { recursive: true, force: true });
-      mkdirSync(isolatedRoot, { recursive: true });
-      copyFileSync(resolve(node.path, "package.json"), resolve(isolatedRoot, "package.json"));
-      runCapturedCommand(node, options, "lockfile", "npm", [
-        "install",
-        "--package-lock-only",
-        "--ignore-scripts",
-        "--workspaces=false",
-        "--no-audit",
-        "--no-fund"
-      ], {
-        cwd: isolatedRoot,
-        timeoutMs: 15 * 6e4
-      });
-      runCapturedCommand(node, options, "lockfile", "npm", validateArgs, {
-        cwd: isolatedRoot,
-        timeoutMs: 5 * 6e4
-      });
-      copyFileSync(resolve(isolatedRoot, "package-lock.json"), lockfilePath);
-    } catch (regenerationError) {
-      if (previousLockfile !== null) writeFileSync(lockfilePath, previousLockfile, "utf8");
-      throw regenerationError instanceof Error ? regenerationError : validationError;
-    }
-  } finally {
-    rmSync(isolatedRoot, { recursive: true, force: true });
-  }
-  emitProgress(options, node, "lockfile", "Validated the standalone lockfile against the committed package manifest.");
-  return true;
-}
-function planPackageVersion(node, options) {
-  if (!node.packageJson || !node.packageJsonPath) return null;
-  const current = String(node.packageJson.version ?? "0.0.0");
-  return node.branchMode === "package-release-main" ? incrementVersion(current, options.bump ?? "patch") : nextDevVersion(current, options.branch);
-}
-function applyPackageVersion(node, version) {
-  if (!node.packageJson || !node.packageJsonPath) return false;
-  let changed = false;
-  if (node.packageJson.version !== version) {
-    node.packageJson.version = version;
-    writeJson(node.packageJsonPath, node.packageJson);
-    changed = true;
-  }
-  const lockfilePath = resolve(node.path, "package-lock.json");
-  if (existsSync(lockfilePath)) {
-    const lockfile = readJson(lockfilePath);
-    const rootEntry = lockfile.packages && typeof lockfile.packages === "object" && !Array.isArray(lockfile.packages) ? lockfile.packages[""] : null;
-    const lockfileMatches = lockfile.version === version && rootEntry?.version === version && (typeof node.packageJson.name !== "string" || rootEntry?.name === node.packageJson.name);
-    if (lockfileMatches) return changed;
-    lockfile.version = version;
-    const packages = lockfile.packages && typeof lockfile.packages === "object" && !Array.isArray(lockfile.packages) ? lockfile.packages : {};
-    packages[""] = {
-      ...packages[""] ?? {},
-      ...typeof node.packageJson.name === "string" ? { name: node.packageJson.name } : {},
-      version
-    };
-    lockfile.packages = packages;
-    writeJson(lockfilePath, lockfile);
-    changed = true;
-  }
-  return changed;
-}
-function shouldSkipNetworkInstall() {
-  return process.env.TREESEED_SAVE_NPM_INSTALL_MODE !== "allow";
-}
-function shouldSkipGitDependencySmoke(options) {
-  return shouldSkipNetworkInstall() || process.env.TREESEED_GIT_DEPENDENCY_SMOKE === "skip" || options?.verifyMode === "skip";
-}
-function hasNpmLockfile(repoDir) {
-  return existsSync(resolve(repoDir, "package-lock.json")) || existsSync(resolve(repoDir, "npm-shrinkwrap.json"));
-}
-function syncRootWorkspaceLockfileMetadata(node, options) {
-  if (node.path !== options.root || !Array.isArray(node.packageJson?.workspaces)) return false;
-  const lockfilePath = resolve(node.path, "package-lock.json");
-  if (!existsSync(lockfilePath)) return false;
-  const lockfile = readJson(lockfilePath);
-  const packages = lockfile.packages;
-  if (!packages || typeof packages !== "object" || Array.isArray(packages)) return false;
-  let changed = false;
-  const packageEntries = packages;
-  const rootEntry = packageEntries[""] ?? {};
-  const workspacePackageList = workspacePackages(node.path);
-  const workspaceVersionByName = new Map(workspacePackageList.map((workspacePackage) => [String(workspacePackage.packageJson.name ?? ""), String(workspacePackage.packageJson.version ?? "")]).filter(([name, version]) => name.length > 0 && version.length > 0));
-  const rootDependencySpecs = /* @__PURE__ */ new Map();
-  for (const field of dependencyFields(node.packageJson)) {
-    const rootDeps = node.packageJson[field];
-    if (!rootDeps || typeof rootDeps !== "object" || Array.isArray(rootDeps)) continue;
-    for (const [dependencyName, dependencySpec] of Object.entries(rootDeps)) {
-      if (typeof dependencySpec === "string") {
-        rootDependencySpecs.set(dependencyName, dependencySpec);
-      }
-    }
-  }
-  const stableWorkspaceDependencySpec = (dependencyName) => rootDependencySpecs.get(dependencyName) ?? workspaceVersionByName.get(dependencyName) ?? null;
-  const normalizeWorkspaceDependencySpecs = (value) => Object.fromEntries(
-    Object.entries(value).map(([dependencyName, dependencySpec]) => [
-      dependencyName,
-      workspaceVersionByName.has(dependencyName) ? stableWorkspaceDependencySpec(dependencyName) : dependencySpec
-    ])
-  );
-  if (JSON.stringify(rootEntry.workspaces ?? []) !== JSON.stringify(node.packageJson.workspaces)) {
-    rootEntry.workspaces = node.packageJson.workspaces;
-    packageEntries[""] = rootEntry;
-    changed = true;
-  }
-  for (const field of dependencyFields(node.packageJson)) {
-    const nextValue = node.packageJson[field];
-    if (nextValue && typeof nextValue === "object" && !Array.isArray(nextValue)) {
-      const currentValue = rootEntry[field];
-      const currentDeps = currentValue && typeof currentValue === "object" && !Array.isArray(currentValue) ? currentValue : {};
-      const mergedDeps = { ...currentDeps };
-      let fieldChanged = false;
-      for (const [dependencyName, dependencySpec] of Object.entries(nextValue)) {
-        if (mergedDeps[dependencyName] === dependencySpec) continue;
-        mergedDeps[dependencyName] = dependencySpec;
-        fieldChanged = true;
-      }
-      if (fieldChanged) {
-        rootEntry[field] = mergedDeps;
-        packageEntries[""] = rootEntry;
-        changed = true;
-      }
-    }
-  }
-  for (const workspacePackage of workspacePackageList) {
-    const relativeDir = workspacePackage.relativeDir.replace(/\\/gu, "/");
-    const packageJson = workspacePackage.packageJson;
-    const packageName = String(packageJson.name ?? "");
-    if (!packageName) continue;
-    const packageEntry = packageEntries[relativeDir] ?? {};
-    if (packageEntry.name !== packageName) {
-      packageEntry.name = packageName;
-      changed = true;
-    }
-    if (typeof packageJson.version === "string" && packageEntry.version !== packageJson.version) {
-      packageEntry.version = packageJson.version;
-      changed = true;
-    }
-    for (const field of dependencyFields(packageJson)) {
-      const nextValue = packageJson[field];
-      if (nextValue && typeof nextValue === "object" && !Array.isArray(nextValue)) {
-        const normalizedValue = normalizeWorkspaceDependencySpecs(nextValue);
-        if (JSON.stringify(packageEntry[field] ?? {}) !== JSON.stringify(normalizedValue)) {
-          packageEntry[field] = normalizedValue;
-          changed = true;
-        }
-      }
-    }
-    packageEntries[relativeDir] = packageEntry;
-    const linkKey = `node_modules/${packageName}`;
-    const linkEntry = packageEntries[linkKey] ?? {};
-    if (linkEntry.resolved !== relativeDir) {
-      linkEntry.resolved = relativeDir;
-      changed = true;
-    }
-    if (linkEntry.link !== true) {
-      linkEntry.link = true;
-      changed = true;
-    }
-    packageEntries[linkKey] = linkEntry;
-  }
-  if (!changed) return false;
-  lockfile.packages = packageEntries;
-  writeJson(lockfilePath, lockfile);
-  emitProgress(options, node, "lockfile", "Synchronized root workspace lockfile metadata before validation.");
-  return true;
-}
-async function runGitDependencySmoke(node, options, reference) {
-  void node;
-  void options;
-  void reference;
-}
-async function runNpmInstallWithRetry(node, options, gitDependencyRefreshSpecs = []) {
-  if (shouldSkipNetworkInstall() || options.deferPushUntilVerified === true) {
-    const reason = options.deferPushUntilVerified === true ? "atomic-save" : "disabled";
-    emitProgress(options, node, "install", `Skipped npm install because ${reason === "atomic-save" ? "atomic save validates local lock metadata before publishing commits" : "network install mode is disabled"}.`);
-    return { status: "skipped", attempts: 0, reason };
-  }
-  let lastError = null;
-  const packageJson = node.packageJson ?? (existsSync(resolve(node.path, "package.json")) ? readJson(resolve(node.path, "package.json")) : null);
-  const rootWorkspaceInstall = node.path === options.root && Array.isArray(packageJson?.workspaces);
-  if (!rootWorkspaceInstall && node.branchMode !== "project-save") {
-    validateStandaloneGitDependencyLockfile(node, options);
-    return { status: "completed", attempts: 1, reason: "isolated-lockfile-validation" };
-  }
-  const installFlags = rootWorkspaceInstall ? ["--package-lock-only", "--ignore-scripts"] : node.branchMode === "project-save" ? ["--ignore-scripts"] : ["--package-lock-only", "--ignore-scripts"];
-  const args = rootWorkspaceInstall ? gitDependencyRefreshSpecs.length > 0 ? ["install", ...gitDependencyRefreshSpecs, ...installFlags, "--force"] : ["install", ...installFlags] : gitDependencyRefreshSpecs.length > 0 ? ["install", ...gitDependencyRefreshSpecs, ...installFlags, "--force", "--workspaces=false"] : ["install", ...installFlags, "--workspaces=false"];
-  for (let attempt = 1; attempt <= 5; attempt += 1) {
-    emitProgress(options, node, "install", `npm ${args.join(" ")} attempt ${attempt}/5.`);
-    try {
-      await runStreamingCommand(node, options, "install", "npm", args);
-      return { status: "completed", attempts: attempt, reason: null };
-    } catch (error) {
-      lastError = error instanceof Error ? error.message : String(error);
-    }
-    if (attempt < 5) {
-      emitProgress(options, node, "install", "npm install failed; retrying in 60 seconds.", "stderr");
-      await sleepMs(6e4);
-    }
-  }
-  throw new RepositorySaveError(`npm install failed after 5 attempts.
-${lastError ?? ""}`);
-}
-async function runProjectVerificationInstallWithRetry(node, options) {
-  if (!hasNpmLockfile(node.path)) return;
-  if (shouldSkipNetworkInstall()) {
-    emitProgress(options, node, "install", "Skipped project verification dependency install because network install mode is disabled.");
-    return;
-  }
-  let lastError = null;
-  const packageJson = node.packageJson ?? (existsSync(resolve(node.path, "package.json")) ? readJson(resolve(node.path, "package.json")) : null);
-  const rootWorkspaceInstall = node.path === options.root && Array.isArray(packageJson?.workspaces);
-  if (rootWorkspaceInstall) {
-    emitProgress(options, node, "install", "Skipped root npm ci project verification install; lockfile plan and restored workspace links provide save-time dependency proof.");
-    return;
-  }
-  const args = rootWorkspaceInstall ? ["ci"] : ["ci", "--workspaces=false"];
-  for (let attempt = 1; attempt <= 5; attempt += 1) {
-    emitProgress(options, node, "install", `npm ${args.join(" ")} for project verification attempt ${attempt}/5.`);
-    try {
-      await runStreamingCommand(node, options, "install", "npm", args);
-      return;
-    } catch (error) {
-      lastError = error instanceof Error ? error.message : String(error);
-    }
-    if (attempt < 5) {
-      emitProgress(options, node, "install", "npm ci for verification failed; retrying in 60 seconds.", "stderr");
-      await sleepMs(6e4);
-    }
-  }
-  throw new RepositorySaveError(`Project verification dependency install failed after 5 attempts.
-${lastError ?? ""}`);
-}
-function lockfileValidationCommand(node, options) {
-  const packageJson = node.packageJson ?? (existsSync(resolve(node.path, "package.json")) ? readJson(resolve(node.path, "package.json")) : null);
-  const rootWorkspaceInstall = node.path === options.root && Array.isArray(packageJson?.workspaces);
-  const args = rootWorkspaceInstall ? ["ci", "--ignore-scripts", "--plan"] : ["ci", "--ignore-scripts", "--plan", "--workspaces=false"];
-  return { command: "npm", args };
-}
-function lockfileValidationTimeoutMs(node, options) {
-  const packageJson = node.packageJson ?? (existsSync(resolve(node.path, "package.json")) ? readJson(resolve(node.path, "package.json")) : null);
-  const rootWorkspaceInstall = node.path === options.root && Array.isArray(packageJson?.workspaces);
-  return rootWorkspaceInstall ? 18e5 : 6e5;
-}
-async function validateRepositoryLockfile(node, options) {
-  if (!hasNpmLockfile(node.path)) {
-    return { status: "skipped", command: null, issues: [], error: "no npm lockfile" };
-  }
-  syncRootWorkspaceLockfileMetadata(node, options);
-  const issues = collectDeploymentLockfileWorkspaceIssues(node.path).map((issue) => `${issue.filePath}: ${issue.packageName} ${issue.reason}`);
-  if (issues.length > 0) {
-    throw new RepositorySaveError([
-      `Lockfile validation failed for ${node.name}.`,
-      ...issues
-    ].join("\n"), {
-      details: {
-        failingRepo: node.name,
-        phase: "lockfile",
-        issues
-      }
-    });
-  }
-  const { command, args } = lockfileValidationCommand(node, options);
-  const commandText = `${command} ${args.join(" ")}`;
-  if (shouldSkipNetworkInstall() || options.deferPushUntilVerified === true) {
-    const reason = options.deferPushUntilVerified === true ? "atomic-save" : "disabled";
-    emitProgress(options, node, "lockfile", `Validated lockfile structure without ${commandText} because ${reason === "atomic-save" ? "upstream commits are intentionally unpublished" : "network install mode is disabled"}.`);
-    return { status: "passed", command: "treeseed structural lockfile validation", issues: [], error: null };
-  }
-  try {
-    runCapturedCommand(node, options, "lockfile", command, args, { timeoutMs: lockfileValidationTimeoutMs(node, options), emitOutputOnSuccess: false });
-    const packageCount = npmLockfilePackageCount(node.path);
-    const countText = packageCount === null ? "package-lock entries" : `${packageCount} package${packageCount === 1 ? "" : "s"}`;
-    emitProgress(options, node, "lockfile", `Lockfile validation passed: ${countText} checked, 0 issues.`);
-    return { status: "passed", command: commandText, issues: [], error: null };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const result = { status: "failed", command: commandText, issues: [message], error: message };
-    throw new RepositorySaveError([
-      `Lockfile validation failed for ${node.name}.`,
-      `Command: ${commandText}`,
-      message
-    ].join("\n"), {
-      details: {
-        failingRepo: node.name,
-        phase: "lockfile",
-        command: commandText,
-        issues: result.issues
-      }
-    });
-  }
-}
-function hasScript(node, scriptName) {
-  return typeof node.scripts[scriptName] === "string" && node.scripts[scriptName].length > 0;
-}
-function manifestVerifyCommand(node, key) {
-  return node.manifestVerifyCommands[key] ?? null;
-}
-function hasAnyVerificationCommand(node) {
-  return hasScript(node, "verify:action") || hasScript(node, "verify:local") || hasScript(node, "verify") || Boolean(manifestVerifyCommand(node, "local")) || Boolean(manifestVerifyCommand(node, "fast"));
-}
-async function runScript(node, options, scriptName) {
-  await runStreamingCommand(node, options, "verify", "npm", ["run", scriptName]);
-}
-async function runManifestVerifyCommand(node, options, verifyMode, key) {
-  const manifestCommand = manifestVerifyCommand(node, key);
-  if (!manifestCommand) {
-    throw new RepositorySaveError(`${node.name} is missing a ${key} verification command in treeseed.package.yaml.`);
-  }
-  const command = `${manifestCommand.command} ${manifestCommand.args.join(" ")}`;
-  const cacheInput = {
-    workspaceRoot: options.root,
-    repoName: node.name,
-    repoPath: node.path,
-    command,
-    verifyMode,
-    env: process.env
-  };
-  const cached = readTreeseedVerificationCache(cacheInput);
-  if (cached) {
-    emitProgress(options, node, "verify", `[verify][cache] Reused ${node.name} ${manifestCommand.label} for ${cached.headSha.slice(0, 12)}.`);
-    return { cached: true };
-  }
-  const started = Date.now();
-  await runStreamingCommand(node, options, "verify", manifestCommand.command, manifestCommand.args, { cwd: manifestCommand.cwd });
-  writeTreeseedVerificationCache(cacheInput, Date.now() - started);
-  return { cached: false };
-}
-async function runCachedScript(node, options, verifyMode, scriptName) {
-  const command = `npm run ${scriptName}`;
-  const cacheInput = {
-    workspaceRoot: options.root,
-    repoName: node.name,
-    repoPath: node.path,
-    command,
-    verifyMode,
-    env: process.env
-  };
-  const cached = readTreeseedVerificationCache(cacheInput);
-  if (cached) {
-    emitProgress(options, node, "verify", `[verify][cache] Reused ${node.name} ${scriptName} for ${cached.headSha.slice(0, 12)}.`);
-    return { cached: true };
-  }
-  const started = Date.now();
-  await runScript(node, options, scriptName);
-  writeTreeseedVerificationCache(cacheInput, Date.now() - started);
-  return { cached: false };
-}
-async function runRepoVerification(node, options, verifyMode) {
-  if (verifyMode === "skip") {
-    emitProgress(options, node, "verify", "Skipped verification by request.");
-    return { mode: verifyMode, status: "skipped", primary: null, fallbackUsed: false, error: null };
-  }
-  if (node.kind !== "package" && !hasAnyVerificationCommand(node)) {
-    emitProgress(options, node, "verify", "Skipped verification because project repository does not declare a Treeseed verify script.");
-    return { mode: verifyMode, status: "skipped", primary: null, fallbackUsed: false, error: null };
-  }
-  await runProjectVerificationInstallWithRetry(node, options);
-  if (verifyMode === "local-only") {
-    if (hasScript(node, "verify:local")) {
-      await runCachedScript(node, options, verifyMode, "verify:local");
-      return { mode: verifyMode, status: "passed", primary: "verify:local", fallbackUsed: false, error: null };
-    }
-    if (manifestVerifyCommand(node, "local")) {
-      await runManifestVerifyCommand(node, options, verifyMode, "local");
-      return { mode: verifyMode, status: "passed", primary: "manifest:local", fallbackUsed: false, error: null };
-    }
-    if (manifestVerifyCommand(node, "fast")) {
-      await runManifestVerifyCommand(node, options, verifyMode, "fast");
-      return { mode: verifyMode, status: "passed", primary: "manifest:fast", fallbackUsed: false, error: null };
-    }
-    if (!hasScript(node, "verify:local")) {
-      throw new RepositorySaveError(`${node.kind === "package" ? "Package" : "Project"} ${node.name} is missing required verify:local script.`);
-    }
-  }
-  if (!hasAnyVerificationCommand(node)) {
-    throw new RepositorySaveError(`${node.kind === "package" ? "Package" : "Project"} ${node.name} is missing required verify:action, verify:local, or verify script.`);
-  }
-  if (hasScript(node, "verify:action")) {
-    try {
-      await runCachedScript(node, options, verifyMode, "verify:action");
-      return { mode: verifyMode, status: "passed", primary: "verify:action", fallbackUsed: false, error: null };
-    } catch (error) {
-      if (!hasScript(node, "verify:local")) {
-        throw error;
-      }
-      emitProgress(options, node, "verify", "verify:action failed; falling back to verify:local.", "stderr");
-      await runCachedScript(node, options, verifyMode, "verify:local");
-      return {
-        mode: verifyMode,
-        status: "passed",
-        primary: "verify:action",
-        fallbackUsed: true,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  if (hasScript(node, "verify:local")) {
-    await runCachedScript(node, options, verifyMode, "verify:local");
-    return { mode: verifyMode, status: "passed", primary: "verify:local", fallbackUsed: true, error: null };
-  }
-  if (manifestVerifyCommand(node, "local")) {
-    await runManifestVerifyCommand(node, options, verifyMode, "local");
-    return { mode: verifyMode, status: "passed", primary: "manifest:local", fallbackUsed: true, error: null };
-  }
-  if (manifestVerifyCommand(node, "fast")) {
-    await runManifestVerifyCommand(node, options, verifyMode, "fast");
-    return { mode: verifyMode, status: "passed", primary: "manifest:fast", fallbackUsed: true, error: null };
-  }
-  await runCachedScript(node, options, verifyMode, "verify");
-  return { mode: verifyMode, status: "passed", primary: "verify:local", fallbackUsed: true, error: null };
-}
-function pullRebaseFromOrigin(node, options, branch) {
-  if (!remoteBranchExistsSafe(node.path, branch)) {
-    emitProgress(options, node, "rebase", `Skipped pull --rebase because origin/${branch} does not exist.`);
-    return {
-      remoteBranchExisted: false,
-      pulledRebase: false
-    };
-  }
-  try {
-    runCapturedCommand(node, options, "rebase", "git", ["fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
-    runCapturedCommand(node, options, "rebase", "git", ["rebase", `refs/remotes/origin/${branch}`]);
-    return {
-      remoteBranchExisted: true,
-      pulledRebase: true
-    };
-  } catch (error) {
-    const report = collectMergeConflictReport(node.path);
-    throw new RepositorySaveError(formatMergeConflictReport(report, node.path, branch), {
-      exitCode: 12,
-      details: { branch, report, originalError: error instanceof Error ? error.message : String(error) }
-    });
-  }
-}
-function pushCurrentBranch(node, options, branch, tagName) {
-  ensureWritableRemote(node, options);
-  const remoteBranchExists2 = remoteBranchExistsSafe(node.path, branch);
-  let pushedTag = false;
-  const args = remoteBranchExists2 ? ["push", "origin", branch] : ["push", "-u", "origin", branch];
-  if (tagName) {
-    const state = tagState(node.path, tagName);
-    assertTagStateMatchesHead(node, tagName, state, headCommit(node.path));
-    if (!state.remoteExists) {
-      args.push(tagName);
-      pushedTag = true;
-    }
-  }
-  runCapturedCommand(node, options, "push", "git", args);
-  return {
-    createdRemoteBranch: !remoteBranchExists2,
-    pushed: true,
-    pushedTag,
-    combinedBranchAndTagPush: pushedTag
-  };
-}
-async function finishRepositorySavePublish(node, options, state, report, input) {
-  const reference = input.reference ?? null;
-  const tagName = input.tagName ?? reference?.tagName ?? null;
-  const shouldDeferPush = options.deferPushUntilVerified === true;
-  if (shouldDeferPush) {
-    state.deferredPushes.push({
-      node,
-      report,
-      branch: input.branch,
-      tagName,
-      rebase: input.rebase,
-      reference
-    });
-    report.pushed = false;
-    report.publishWait = {
-      ...input.rebase,
-      deferredPush: true
-    };
-    return;
-  }
-  const push = pushCurrentBranch(node, options, input.branch, tagName);
-  if (reference) {
-    await runGitDependencySmoke(node, options, reference);
-    report.dependencySpec = reference.spec;
-  }
-  report.pushed = push.pushed;
-  report.publishWait = {
-    ...input.rebase,
-    ...push
-  };
-}
-async function publishDeferredRepositoryPushes(options, state) {
-  if (state.deferredPushes.length === 0) return;
-  for (const deferred of state.deferredPushes) {
-    const push = pushCurrentBranch(deferred.node, options, deferred.branch, deferred.tagName);
-    if (deferred.reference) {
-      await runGitDependencySmoke(deferred.node, options, deferred.reference);
-      deferred.report.dependencySpec = deferred.reference.spec;
-    }
-    deferred.report.pushed = push.pushed;
-    deferred.report.publishWait = {
-      ...deferred.rebase,
-      ...push,
-      deferredPush: true
-    };
-  }
-  state.deferredPushes = [];
-}
-function tagExists(repoDir, tagName) {
-  try {
-    runGit(["rev-parse", "--verify", `refs/tags/${tagName}`], { cwd: repoDir, capture: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function localTagCommit(repoDir, tagName) {
-  try {
-    return runGit(["rev-list", "-n", "1", tagName], { cwd: repoDir, capture: true }).trim();
-  } catch {
-    return null;
-  }
-}
-function remoteTagCommit(repoDir, tagName) {
-  try {
-    const output = runGit(["ls-remote", "--tags", "origin", `refs/tags/${tagName}*`], { cwd: repoDir, capture: true });
-    const lines = output.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
-    const dereferenced = lines.find((line) => line.endsWith(`refs/tags/${tagName}^{}`));
-    const exact = lines.find((line) => line.endsWith(`refs/tags/${tagName}`));
-    const selected = dereferenced ?? exact;
-    return selected ? selected.split(/\s+/u)[0] ?? null : null;
-  } catch {
-    return null;
-  }
-}
-function localTagMessage(repoDir, tagName) {
-  try {
-    return runGit(["tag", "-l", tagName, "--format=%(contents)"], { cwd: repoDir, capture: true }).trim();
-  } catch {
-    return null;
-  }
-}
-function tagState(repoDir, tagName) {
-  const localCommit = localTagCommit(repoDir, tagName);
-  const remoteCommit = remoteTagCommit(repoDir, tagName);
-  return {
-    tagName,
-    localExists: localCommit != null,
-    localCommit,
-    remoteExists: remoteCommit != null,
-    remoteCommit
-  };
-}
-function assertTagStateMatchesHead(node, tagName, state, head) {
-  if (state.localCommit && state.localCommit !== head) {
-    throw new RepositorySaveError(`Package ${node.name} tag ${tagName} points to ${state.localCommit.slice(0, 12)}, but ${node.name} HEAD is ${head.slice(0, 12)}. Refusing to move an existing tag.`, {
-      details: {
-        failingRepo: node.name,
-        phase: "tag",
-        currentVersion: tagName,
-        expectedTag: tagName,
-        tagState: state
-      }
-    });
-  }
-  if (state.remoteCommit && state.remoteCommit !== head) {
-    throw new RepositorySaveError(`Remote tag ${tagName} for ${node.name} points to ${state.remoteCommit.slice(0, 12)}, but ${node.name} HEAD is ${head.slice(0, 12)}. Refusing to move an existing tag.`, {
-      details: {
-        failingRepo: node.name,
-        phase: "tag",
-        currentVersion: tagName,
-        expectedTag: tagName,
-        tagState: state
-      }
-    });
-  }
-}
-function createPackageTagMessage(node, tagName, branch, workflowRunId) {
-  void branch;
-  void workflowRunId;
-  return `release: ${tagName}`;
-}
-function ensureRemoteAccessBeforeVerification(node, options, state) {
-  if (shouldSkipRemoteAccessPreflight()) return;
-  if (state.remoteAccessChecked.has(node.path)) return;
-  ensureWritableRemote(node, options);
-  const writeUrl = remoteWriteUrl(node.path) ?? "origin";
-  emitProgress(options, node, "preflight", `Checking write remote access before verification (${writeUrl}).`);
-  try {
-    runQuietCommand(node, "preflight", "git", ["ls-remote", "--heads", writeUrl], { timeoutMs: 3e4 });
-    state.remoteAccessChecked.add(node.path);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new RepositorySaveError([
-      `Cannot access origin remote for ${node.name}; save would fail after verification when pushing branch or tags.`,
-      "Fix Git authentication, then rerun `npx trsd save` to resume.",
-      detail
-    ].join("\n"), {
-      exitCode: 13,
-      details: {
-        failingRepo: node.name,
-        phase: "preflight",
-        originalError: detail
-      }
-    });
-  }
-}
-function shouldSkipRemoteAccessPreflight() {
-  return process.env.TREESEED_SAVE_REMOTE_PREFLIGHT === "skip";
-}
-function ensurePackageTagReady(node, options, tagName, branch, workflowRunId) {
-  let message = null;
-  ensureWritableRemote(node, options);
-  const head = headCommit(node.path);
-  let state = tagState(node.path, tagName);
-  assertTagStateMatchesHead(node, tagName, state, head);
-  if (!state.localExists && state.remoteExists && state.remoteCommit === head) {
-    runCapturedCommand(node, options, "tag", "git", ["fetch", "origin", `refs/tags/${tagName}:refs/tags/${tagName}`]);
-    state = tagState(node.path, tagName);
-    assertTagStateMatchesHead(node, tagName, state, head);
-  }
-  if (!state.localExists) {
-    message = createPackageTagMessage(node, tagName, branch, workflowRunId);
-    runCapturedCommand(node, options, "tag", "git", ["tag", "-a", tagName, "-m", message]);
-    state = tagState(node.path, tagName);
-    assertTagStateMatchesHead(node, tagName, state, head);
-  }
-  if (state.remoteExists) {
-    emitProgress(options, node, "tag", `Remote tag ${tagName} already points at HEAD.`);
-  }
-  return message;
-}
-function treeCommitForPath(repoDir, ref, path) {
-  try {
-    const output = runGit(["ls-tree", ref, "--", path], { cwd: repoDir, capture: true }).trim();
-    const match = output.match(/^\d+\s+commit\s+([0-9a-f]{40})\t/u);
-    return match?.[1] ?? null;
-  } catch {
-    return null;
-  }
-}
-function collectSubmodulePointerChanges(node, finalizedCommits) {
-  const changes = [];
-  for (const [repoName, finalizedCommit] of finalizedCommits.entries()) {
-    const childRelativePath = node.id === "." ? repoName : repoName.startsWith(`${node.id}/`) ? repoName.slice(node.id.length + 1) : null;
-    if (!childRelativePath) continue;
-    const childPath = resolve(node.path, childRelativePath);
-    if (!existsSync(childPath) || !isGitRepo(childPath)) continue;
-    const status = runGit(["status", "--porcelain", "--", childRelativePath], { cwd: node.path, capture: true });
-    const oldSha = treeCommitForPath(node.path, "HEAD", childRelativePath);
-    const newSha = finalizedCommit || headCommit(childPath);
-    if (status.trim().length > 0 || oldSha && newSha && oldSha !== newSha) {
-      changes.push({
-        path: childRelativePath,
-        oldSha,
-        newSha
-      });
-    }
-  }
-  return changes;
-}
-function commitContextDependencyUpdates(updates) {
-  return updates.map((update) => ({
-    packageName: update.packageName,
-    field: update.field,
-    from: update.from,
-    to: update.to,
-    tagName: update.tagName
-  }));
-}
-function commitContextPackageChanges(node, state, submodulePointers) {
-  const pointersByPath = new Map(submodulePointers.map((pointer) => [pointer.path, pointer]));
-  const changes = [];
-  for (const [relativePath, report] of state.reports.entries()) {
-    if (relativePath === node.id || relativePath === ".") continue;
-    const childRelativePath = node.id === "." ? relativePath : relativePath.startsWith(`${node.id}/`) ? relativePath.slice(node.id.length + 1) : null;
-    if (!childRelativePath) continue;
-    const pointer = pointersByPath.get(childRelativePath);
-    if (!pointer && !report.committed && !report.tagName && !report.dependencySpec) continue;
-    changes.push({
-      name: report.name,
-      path: childRelativePath,
-      oldSha: pointer?.oldSha ?? null,
-      newSha: pointer?.newSha ?? report.commitSha,
-      tagName: report.tagName,
-      version: report.version,
-      dependencySpec: report.dependencySpec,
-      commitSubject: commitSubject(report.commitMessage)
-    });
-    if (pointer) {
-      pointer.packageName = report.name;
-    }
-  }
-  return changes;
-}
-function syncBranchBeforeSave(node, options, branch) {
-  checkoutOrCreateBranch(node, options, branch);
-}
-function refreshRepositoryNodePackageMetadata(node) {
-  const packageJsonPath = resolve(node.path, "package.json");
-  const packageJson = existsSync(packageJsonPath) ? readJson(packageJsonPath) : null;
-  node.packageJsonPath = packageJson ? packageJsonPath : null;
-  node.packageJson = packageJson;
-  node.scripts = packageScripts(packageJson);
-  node.remoteUrl = originRemoteUrlSafe(node.path);
-  if (node.kind === "package" && packageJson) {
-    node.name = repoDisplayName(node.path, packageJson);
-  }
-}
-function finalizePackageReference(node, version, options) {
-  const reference = createPackageDependencyReference({
-    packageName: node.name,
-    version,
-    branchMode: node.branchMode === "package-release-main" ? "package-release-main" : "package-dev-save",
-    remoteUrl: node.remoteUrl,
-    commitSha: headCommit(node.path),
-    devDependencyReferenceMode: options.devDependencyReferenceMode ?? "git-commit",
-    gitDependencyProtocol: options.gitDependencyProtocol ?? "preserve-origin"
-  });
-  node.plannedDependencySpec = reference.spec;
-  return reference;
-}
-async function finalizeCleanPackageVersion(node, options, state, report, branch) {
-  const version = typeof node.packageJson?.version === "string" ? node.packageJson.version : null;
-  if (!version || !packageVersionEligibleForBranch(node, version, options)) {
-    return false;
-  }
-  const head = headCommit(node.path);
-  const reference = finalizePackageReference(node, version, options);
-  const currentTagState = reference.tagName ? tagState(node.path, reference.tagName) : null;
-  if (reference.tagName && currentTagState) {
-    assertTagStateMatchesHead(node, reference.tagName, currentTagState, head);
-  }
-  const remoteBranchExists2 = remoteBranchExistsSafe(node.path, branch);
-  const remoteBranchCommit = remoteBranchCommitSafe(node.path, branch);
-  const finalizedRemotely = remoteBranchExists2 && remoteBranchCommit === head && (!reference.tagName || currentTagState?.localCommit === head && currentTagState?.remoteCommit === head);
-  report.version = version;
-  report.tagName = reference.tagName;
-  report.commitSha = head;
-  report.dependencySpec = reference.spec;
-  state.finalizedVersions.set(node.name, version);
-  state.finalizedReferences.set(node.name, reference);
-  state.finalizedCommits.set(node.relativePath, head);
-  if (finalizedRemotely) {
-    report.pushed = true;
-    report.skippedReason = "already-finalized";
-    report.publishWait = { recoveredPartialSave: true, remoteBranchExisted: true, tagAlreadyPushed: Boolean(reference.tagName) };
-    emitProgress(options, node, "finalize", `Using existing finalized package version ${version}.`);
-    return true;
-  }
-  emitProgress(options, node, "finalize", `Finalizing interrupted package version ${version}.`);
-  if (hasNpmLockfile(node.path)) {
-    report.install = await runNpmInstallWithRetry(node, options);
-    report.lockfileValidation = await validateRepositoryLockfile(node, options);
-  }
-  const rebase = pullRebaseFromOrigin(node, options, branch);
-  ensureRemoteAccessBeforeVerification(node, options, state);
-  report.verification = await runRepoVerification(node, options, options.verifyMode ?? "action-first");
-  report.verified = report.verification.status === "passed";
-  const tagMessage = reference.tagName ? ensurePackageTagReady(node, options, reference.tagName, branch, options.workflowRunId) : null;
-  void tagMessage;
-  report.dependencySpec = reference.spec;
-  report.skippedReason = "finalized-partial-save";
-  report.commitSha = headCommit(node.path);
-  state.finalizedCommits.set(node.relativePath, report.commitSha);
-  await finishRepositorySavePublish(node, options, state, report, {
-    branch,
-    rebase: {
-      ...rebase,
-      recoveredPartialSave: true
-    },
-    reference,
-    tagName: reference.tagName
-  });
-  return true;
-}
-function branchModeLabel(branchMode) {
-  switch (branchMode) {
-    case "package-release-main":
-      return "stable package release";
-    case "package-dev-save":
-      return "dev package save";
-    case "project-save":
-      return "project save";
-  }
-}
-function repoPlanCommands(node, options, plannedVersion, plannedDependencySpec, dependencyUpdates) {
-  const branch = node.branch || options.branch;
-  const remoteExists = remoteBranchExistsSafe(node.path, branch);
-  const commands = [
-    checkoutCommandFor(node.path, branch)
-  ];
-  const sshPushUrl = (options.gitRemoteWriteMode ?? "ssh-pushurl") === "off" ? null : sshPushUrlForRemote(node.remoteUrl);
-  if (sshPushUrl) {
-    commands.push(`git remote set-url --push origin ${sshPushUrl} # keep ${node.remoteUrl} for reads`);
-  }
-  if (dependencyUpdates.length > 0) {
-    commands.push(`update package.json internal dependencies: ${dependencyUpdates.join(", ")}`);
-  }
-  if (node.submoduleDependencies.length > 0) {
-    commands.push(`refresh submodule pointers: ${node.submoduleDependencies.join(", ")}`);
-  }
-  const packageJson = node.packageJson ?? (existsSync(resolve(node.path, "package.json")) ? readJson(resolve(node.path, "package.json")) : null);
-  const rootWorkspaceInstall = node.path === options.root && Array.isArray(packageJson?.workspaces);
-  if (node.kind === "package" && plannedVersion) {
-    commands.push(`update package.json version to ${plannedVersion}`);
-    commands.push("npm install --workspaces=false # explicitly refresh changed git commit dependencies with --force; retry up to 5 times with 60s delay");
-  } else if (node.kind === "project" && (dependencyUpdates.length > 0 || rootWorkspaceInstall && node.submoduleDependencies.length > 0) && hasNpmLockfile(node.path)) {
-    commands.push(rootWorkspaceInstall ? "npm install --package-lock-only --ignore-scripts # refresh root workspace lockfile without installing git dependencies" : "npm install --workspaces=false # refresh project lockfile after internal dependency updates");
-  }
-  if (hasNpmLockfile(node.path) && (node.kind === "project" || plannedVersion || dependencyUpdates.length > 0 || node.submoduleDependencies.length > 0)) {
-    commands.push(rootWorkspaceInstall ? "npm ci --ignore-scripts --plan # validate root manifest, workspaces, and lockfile before commit" : "npm ci --ignore-scripts --plan --workspaces=false # validate deployment lockfile before commit");
-  }
-  commands.push("git add -A");
-  commands.push("generate commit message # Cloudflare AI when configured, fallback otherwise");
-  commands.push("git commit -m <generated-message>");
-  commands.push(
-    remoteExists ? `git pull --rebase --recurse-submodules=no origin ${branch}` : `skip pull --rebase # origin/${branch} does not exist yet`
-  );
-  const verifyMode = options.verifyMode ?? "action-first";
-  if (verifyMode === "skip") {
-    commands.push(node.kind === "package" ? "skip package verification" : "skip project verification");
-  } else if (hasScript(node, "verify:action") || hasScript(node, "verify:local") || hasScript(node, "verify")) {
-    if (verifyMode === "local-only") {
-      commands.push("npm run verify:local");
-    } else if (hasScript(node, "verify:action")) {
-      commands.push("npm run verify:action # fallback to npm run verify:local on failure");
-    } else if (hasScript(node, "verify:local")) {
-      commands.push("npm run verify:local");
-    } else {
-      commands.push("npm run verify");
-    }
-  } else if (manifestVerifyCommand(node, "local") || manifestVerifyCommand(node, "fast")) {
-    const command = verifyMode === "local-only" ? manifestVerifyCommand(node, "local") ?? manifestVerifyCommand(node, "fast") : manifestVerifyCommand(node, "local") ?? manifestVerifyCommand(node, "fast");
-    if (command) commands.push(`${command.command} ${command.args.join(" ")} # treeseed.package.yaml verification`);
-  } else if (node.kind !== "package") {
-    commands.push("skip verification # project repository has no Treeseed verify script");
-  }
-  if (node.kind === "package") {
-    const plansTag = plannedVersion && node.branchMode === "package-release-main";
-    if (plannedVersion && plansTag) {
-      commands.push(`git tag -a ${plannedVersion} -m <release>`);
-      commands.push(remoteExists ? `git push origin ${branch} ${plannedVersion}` : `git push -u origin ${branch} ${plannedVersion}`);
-    } else if (plannedVersion) {
-      commands.push(remoteExists ? `git push origin ${branch}` : `git push -u origin ${branch}`);
-      if (plannedDependencySpec && node.branchMode === "package-dev-save") {
-        commands.push(`npm install ${node.name}@${plannedDependencySpec} --package-lock-only --ignore-scripts --force # validate dependency commit reachability`);
-      }
-    } else {
-      commands.push(remoteExists ? `git push origin ${branch}` : `git push -u origin ${branch}`);
-    }
-  } else {
-    commands.push(remoteExists ? `git push origin ${branch}` : `git push -u origin ${branch}`);
-  }
-  return commands;
-}
-function planRepositorySave(options) {
-  const scope = options.branch === STAGING_BRANCH ? "staging" : options.branch === PRODUCTION_BRANCH ? "prod" : "local";
-  const allNodes = discoverRepositorySaveNodes(options.root, options.gitRoot, options.branch, {
-    stablePackageRelease: options.stablePackageRelease === true
-  });
-  const nodes = options.includeRoot === false ? allNodes.filter((node) => node.id !== ".") : allNodes;
-  const mode = nodes.some((node) => node.id !== ".") ? "recursive-workspace" : "root-only";
-  const waves = repositorySaveWaves(nodes);
-  const plannedVersions = /* @__PURE__ */ new Map();
-  const plannedReferences = /* @__PURE__ */ new Map();
-  const plans = /* @__PURE__ */ new Map();
-  for (const wave of waves) {
-    for (const node of wave) {
-      const dependencyUpdates = node.dependencies.map((id) => nodes.find((candidate) => candidate.id === id)).filter((candidate) => Boolean(candidate)).map((dependency) => {
-        const reference = plannedReferences.get(dependency.name);
-        return reference ? `${dependency.name} -> ${reference.spec}` : null;
-      }).filter((value) => Boolean(value));
-      const dependencyChanged = dependencyUpdates.length > 0;
-      const submoduleChanged = node.submoduleDependencies.length > 0 && node.submoduleDependencies.some((id) => {
-        const dependency = plans.get(id);
-        return dependency?.dirty || Boolean(dependency?.plannedVersion);
-      });
-      const dirty = hasMeaningfulChanges(node.path);
-      const packageNeedsVersion = canManagePackageJsonVersion(node) && (dirty || dependencyChanged || submoduleChanged);
-      const currentVersion = typeof node.packageJson?.version === "string" ? node.packageJson.version : null;
-      const plannedVersion = packageNeedsVersion ? selectPackageVersion(node, options).version : null;
-      let plannedDependencySpec = null;
-      if (node.kind === "package" && plannedVersion) {
-        const reference = createPackageDependencyReference({
-          packageName: node.name,
-          version: plannedVersion,
-          branchMode: node.branchMode === "package-release-main" ? "package-release-main" : "package-dev-save",
-          remoteUrl: node.remoteUrl,
-          commitSha: headCommitOrPlanPlaceholder(node.path),
-          devDependencyReferenceMode: options.devDependencyReferenceMode ?? "git-commit",
-          gitDependencyProtocol: options.gitDependencyProtocol ?? "preserve-origin"
-        });
-        plannedDependencySpec = reference.spec;
-        plannedVersions.set(node.name, plannedVersion);
-        plannedReferences.set(node.name, reference);
-      }
-      const current = currentBranch(node.path) || null;
-      const branch = node.branch || options.branch;
-      const notes = [
-        `${branchModeLabel(node.branchMode)} on top-level ${options.branch}`,
-        ...current && current !== branch ? [`current branch ${current} will be switched to ${branch}`] : [],
-        ...node.kind === "package" && plannedVersion?.includes("-dev.") ? ["development and staging dependency refs use the package commit SHA; no Git tag is created"] : []
-      ];
-      const repoPlan = {
-        id: node.id,
-        name: node.name,
-        path: node.path,
-        relativePath: node.relativePath,
-        kind: node.kind,
-        currentBranch: current,
-        targetBranch: branch,
-        branchMode: node.branchMode,
-        dirty,
-        dependencies: node.dependencies,
-        dependents: node.dependents,
-        submoduleDependencies: node.submoduleDependencies,
-        currentVersion,
-        plannedVersion,
-        plannedTag: plannedReferences.get(node.name)?.tagName ?? null,
-        plannedDependencySpec,
-        remoteUrl: node.remoteUrl,
-        commands: repoPlanCommands(node, options, plannedVersion, plannedDependencySpec, dependencyUpdates),
-        notes
-      };
-      plans.set(node.id, repoPlan);
-    }
-  }
-  const rootNode = nodes.find((node) => node.id === ".") ?? allNodes.find((node) => node.id === ".");
-  const rootRepo = rootNode ? plans.get(rootNode.id) : null;
-  if (!rootRepo) {
-    throw new RepositorySaveError("Unable to build repository save plan for root repository.");
-  }
-  const repoPlans = nodes.filter((node) => node.id !== ".").sort(compareNodes).map((node) => plans.get(node.id)).filter((plan) => Boolean(plan));
-  const wavePlans = waves.map((wave, index) => ({
-    index: index + 1,
-    parallel: wave.length > 1,
-    repos: wave.map((node) => node.name),
-    commands: wave.map((node) => ({
-      repo: node.name,
-      commands: plans.get(node.id)?.commands ?? []
-    }))
-  }));
-  return {
-    mode,
-    branch: options.branch,
-    scope,
-    devDependencyReferenceMode: options.devDependencyReferenceMode ?? "git-commit",
-    gitDependencyProtocol: options.gitDependencyProtocol ?? "preserve-origin",
-    verifyMode: options.verifyMode ?? "action-first",
-    commitMessageMode: options.commitMessageMode ?? "auto",
-    repos: repoPlans,
-    rootRepo,
-    waves: wavePlans,
-    plannedVersions: Object.fromEntries(plannedVersions.entries()),
-    plannedSteps: wavePlans.flatMap((wave) => wave.commands.map((entry) => ({
-      id: `wave-${wave.index}-${entry.repo}`,
-      description: `Wave ${wave.index}${wave.parallel ? " parallel" : ""}: ${entry.repo}`
-    })))
-  };
-}
-async function refreshAndValidateRootWorkspaceLockfileForSave(options) {
-  const repoDir = options.gitRoot ?? options.root;
-  const packageJsonPath = resolve(repoDir, "package.json");
-  const packageJson = existsSync(packageJsonPath) ? readJson(packageJsonPath) : null;
-  const node = {
-    id: ".",
-    name: repoDisplayName(repoDir, packageJson),
-    path: repoDir,
-    relativePath: ".",
-    kind: "project",
-    branch: options.branch ?? currentBranch(repoDir) ?? null,
-    branchMode: "project-save",
-    packageJsonPath: packageJson ? packageJsonPath : null,
-    packageJson,
-    scripts: packageScripts(packageJson),
-    manifestVerifyCommands: emptyManifestVerifyCommands(),
-    remoteUrl: originRemoteUrlSafe(repoDir),
-    dependencies: [],
-    dependents: [],
-    submoduleDependencies: [],
-    plannedVersion: null,
-    plannedTag: null,
-    plannedDependencySpec: null
-  };
-  if (!hasNpmLockfile(repoDir)) {
-    return {
-      install: null,
-      lockfileValidation: { status: "skipped", command: null, issues: [], error: "no npm lockfile" }
-    };
-  }
-  const install = await runNpmInstallWithRetry(node, { root: options.root, onProgress: options.onProgress });
-  const lockfileValidation = await validateRepositoryLockfile(node, { root: options.root, onProgress: options.onProgress });
-  return { install, lockfileValidation };
-}
-async function saveOneRepository(node, options, state) {
-  const report = state.reports.get(node.id) ?? createReport(node);
-  state.reports.set(node.id, report);
-  const branch = node.branch || options.branch;
-  emitProgress(options, node, "start", `Starting ${node.branchMode} on ${branch}.`);
-  syncBranchBeforeSave(node, options, branch);
-  node.branch = currentBranch(node.path) || branch;
-  report.branch = node.branch;
-  refreshRepositoryNodePackageMetadata(node);
-  ensureWritableRemote(node, options);
-  const dependencyUpdates = isRootWorkspaceRepository(node, options) ? [] : updateDependencyReferences(node, state.finalizedReferences);
-  const dependencyChanged = dependencyUpdates.length > 0;
-  const directDependencyNames = new Set(dependencyFields(node.packageJson ?? {}).flatMap((field) => {
-    const value = node.packageJson?.[field];
-    return value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value) : [];
-  }));
-  const gitDependencyRefreshReferences = [...state.finalizedReferences.values()].filter((reference) => reference.mode === "dev-git-commit" && directDependencyNames.has(reference.packageName));
-  const deferredGitDependencyValidation = options.deferPushUntilVerified === true && gitDependencyRefreshReferences.length > 0;
-  const lockfileGitDependenciesSynced = syncDirectGitDependencyLockfileEntries(node, options, gitDependencyRefreshReferences);
-  if (!isRootWorkspaceRepository(node, options) && (lockfileGitDependenciesSynced || gitDependencyRefreshReferences.length > 0 && !existsSync(resolve(node.path, "package-lock.json"))) && !deferredGitDependencyValidation) {
-    validateStandaloneGitDependencyLockfile(node, options);
-  }
-  const gitDependencyRefreshSpecs = lockfileGitDependenciesSynced ? [] : gitDependencyRefreshReferences.map((reference) => `${reference.packageName}@${reference.installSpec ?? reference.spec}`);
-  const submodulePointers = collectSubmodulePointerChanges(node, state.finalizedCommits);
-  const submodulesChanged = submodulePointers.length > 0;
-  const packageHasMeaningfulChanges = hasMeaningfulChanges(node.path);
-  const packageNeedsVersion = canManagePackageJsonVersion(node) && (packageHasMeaningfulChanges || dependencyChanged || submodulesChanged || packageVersionTagConflictsWithHead(node, options));
-  let plannedVersion = null;
-  if (packageNeedsVersion) {
-    const selection = selectPackageVersion(node, options);
-    plannedVersion = selection.version;
-    if (!plannedVersion) {
-      throw new RepositorySaveError(`Unable to plan package version for ${node.name}.`);
-    }
-    if (selection.reused) {
-      emitProgress(options, node, "version", `Reusing existing interrupted save version ${plannedVersion}.`);
-    } else {
-      emitProgress(options, node, "version", `Planned ${plannedVersion}.`);
-    }
-    applyPackageVersion(node, plannedVersion);
-    node.plannedVersion = plannedVersion;
-    report.version = plannedVersion;
-    const reference = finalizePackageReference(node, plannedVersion, options);
-    node.plannedTag = reference.tagName;
-    report.tagName = reference.tagName;
-    report.dependencySpec = reference.spec;
-    report.install = await runNpmInstallWithRetry(node, options, gitDependencyRefreshSpecs);
-  } else if (node.kind === "package") {
-    report.version = String(node.packageJson?.version ?? report.version ?? "");
-  } else if (node.kind === "project" && (dependencyChanged || node.path === options.root && submodulesChanged) && hasNpmLockfile(node.path)) {
-    report.install = await runNpmInstallWithRetry(node, options, gitDependencyRefreshSpecs);
-  }
-  if (!isRootWorkspaceRepository(node, options) && hasNpmLockfile(node.path) && (packageNeedsVersion || dependencyChanged) && !deferredGitDependencyValidation) {
-    validateStandaloneGitDependencyLockfile(node, options);
-  }
-  if (hasNpmLockfile(node.path) && (node.kind === "project" || packageNeedsVersion || dependencyChanged || submodulesChanged)) {
-    const lockfileIssues = collectDeploymentLockfileWorkspaceIssues(node.path);
-    if (node.kind === "project" && lockfileIssues.length > 0 && !shouldSkipNetworkInstall()) {
-      emitProgress(options, node, "lockfile", "Refreshing package-lock.json before validation.");
-      report.install = await runNpmInstallWithRetry(node, options, gitDependencyRefreshSpecs);
-    }
-    report.lockfileValidation = await validateRepositoryLockfile(node, options);
-  }
-  const dirty = hasMeaningfulChanges(node.path);
-  report.dirty = dirty;
-  if (!dirty) {
-    report.skippedReason = "clean";
-    report.commitSha = headCommit(node.path);
-    emitProgress(options, node, "clean", "No meaningful changes to commit.");
-    if (node.kind === "package") {
-      const finalized = await finalizeCleanPackageVersion(node, options, state, report, branch);
-      if (finalized) {
-        return report;
-      }
-    }
-    if (node.kind === "project" || node.kind === "package" && !canManagePackageJsonVersion(node)) {
-      const rebase2 = pullRebaseFromOrigin(node, options, branch);
-      await finishRepositorySavePublish(node, options, state, report, { branch, rebase: rebase2 });
-      report.commitSha = headCommit(node.path);
-    }
-    state.finalizedCommits.set(node.relativePath, report.commitSha);
-    return report;
-  }
-  runCapturedCommand(node, options, "commit", "git", ["add", "-A"]);
-  if (!hasStagedChanges(node.path)) {
-    report.dirty = false;
-    report.skippedReason = "clean-after-add";
-    report.commitSha = headCommit(node.path);
-    emitProgress(options, node, "clean", "No staged changes to commit after refreshing the index.");
-    if (node.kind === "package") {
-      const finalized = await finalizeCleanPackageVersion(node, options, state, report, branch);
-      if (finalized) {
-        return report;
-      }
-    }
-    if (node.kind === "project" || node.kind === "package" && !canManagePackageJsonVersion(node)) {
-      const rebase2 = pullRebaseFromOrigin(node, options, branch);
-      await finishRepositorySavePublish(node, options, state, report, { branch, rebase: rebase2 });
-      report.commitSha = headCommit(node.path);
-    }
-    state.finalizedCommits.set(node.relativePath, report.commitSha);
-    return report;
-  }
-  const { changedFiles, diff } = gitDiffSummary(node.path);
-  emitProgress(options, node, "message", "Generating commit message.");
-  const messageResult = await commitMessageFor(node, options, {
-    changedFiles,
-    diff,
-    plannedVersion: plannedVersion ?? report.version,
-    plannedTag: node.plannedTag ?? report.tagName,
-    dependencyUpdates: commitContextDependencyUpdates(dependencyUpdates),
-    submodulePointers,
-    packageChanges: commitContextPackageChanges(node, state, submodulePointers)
-  });
-  report.commitMessage = messageResult.message;
-  report.commitMessageProvider = messageResult.provider;
-  report.commitMessageFallbackUsed = messageResult.fallbackUsed;
-  report.commitMessageError = messageResult.error;
-  emitProgress(options, node, "message", `${messageResult.provider}${messageResult.fallbackUsed ? " fallback" : ""}: ${messageResult.message.split(/\r?\n/u)[0]}`);
-  try {
-    runCapturedCommand(node, options, "commit", "git", ["commit", "-m", messageResult.message]);
-  } catch (error) {
-    if (!isNoOpGitCommitError(error) || hasMeaningfulChanges(node.path) || hasStagedChanges(node.path)) {
-      throw error;
-    }
-    report.dirty = false;
-    report.skippedReason = "clean-at-commit";
-    report.commitSha = headCommit(node.path);
-    emitProgress(options, node, "clean", "No changes remained to commit after Git refreshed the index.");
-    if (node.kind === "package") {
-      const finalized = await finalizeCleanPackageVersion(node, options, state, report, branch);
-      if (finalized) {
-        return report;
-      }
-    }
-    if (node.kind === "project" || node.kind === "package" && !canManagePackageJsonVersion(node)) {
-      const rebase2 = pullRebaseFromOrigin(node, options, branch);
-      await finishRepositorySavePublish(node, options, state, report, { branch, rebase: rebase2 });
-      report.commitSha = headCommit(node.path);
-    }
-    state.finalizedCommits.set(node.relativePath, report.commitSha);
-    return report;
-  }
-  report.committed = true;
-  report.commitSha = headCommit(node.path);
-  const rebase = pullRebaseFromOrigin(node, options, branch);
-  const verifyMode = options.verifyMode ?? "action-first";
-  if (node.kind === "project" && node.path === options.root && Array.isArray(node.packageJson?.workspaces)) {
-    const linkReport = ensureLocalWorkspaceLinks(options.root);
-    const restoredLinks = Array.isArray(linkReport.created) ? linkReport.created.length : 0;
-    if (restoredLinks > 0) {
-      emitProgress(options, node, "install", `Restored ${restoredLinks} local workspace package link${restoredLinks === 1 ? "" : "s"} before project verification.`);
-    }
-  }
-  if (node.kind === "package") {
-    ensureRemoteAccessBeforeVerification(node, options, state);
-  }
-  report.verification = await runRepoVerification(node, options, verifyMode);
-  report.verified = report.verification.status === "passed";
-  if (canManagePackageJsonVersion(node)) {
-    const version = plannedVersion ?? String(readJson(resolve(node.path, "package.json")).version ?? report.version ?? "");
-    const reference = finalizePackageReference(node, version, options);
-    const tagMessage = reference.tagName ? ensurePackageTagReady(node, options, reference.tagName, branch, options.workflowRunId) : null;
-    void tagMessage;
-    report.tagName = reference.tagName;
-    report.version = version;
-    report.dependencySpec = reference.spec;
-    state.finalizedVersions.set(node.name, version);
-    state.finalizedReferences.set(node.name, reference);
-    await finishRepositorySavePublish(node, options, state, report, { branch, rebase, reference, tagName: reference.tagName });
-  } else {
-    await finishRepositorySavePublish(node, options, state, report, { branch, rebase });
-  }
-  report.commitSha = headCommit(node.path);
-  report.skippedReason = null;
-  state.finalizedCommits.set(node.relativePath, report.commitSha);
-  emitProgress(options, node, "done", `Saved ${report.commitSha?.slice(0, 12) ?? "current HEAD"}.`);
-  return report;
-}
-async function runRepositorySaveOrchestrator(options) {
-  const root = options.root;
-  const gitRoot = options.gitRoot;
-  const branch = options.branch;
-  const scope = branch === STAGING_BRANCH ? "staging" : branch === PRODUCTION_BRANCH ? "prod" : "local";
-  const allNodes = discoverRepositorySaveNodes(root, gitRoot, branch, {
-    stablePackageRelease: options.stablePackageRelease === true
-  });
-  const nodes = options.includeRoot === false ? allNodes.filter((node) => node.id !== ".") : allNodes;
-  const mode = nodes.some((node) => node.id !== ".") ? "recursive-workspace" : "root-only";
-  const waves = repositorySaveWaves(nodes);
-  const state = {
-    finalizedVersions: /* @__PURE__ */ new Map(),
-    finalizedReferences: /* @__PURE__ */ new Map(),
-    finalizedCommits: /* @__PURE__ */ new Map(),
-    reports: new Map(nodes.map((node) => [node.id, createReport(node)])),
-    remoteAccessChecked: /* @__PURE__ */ new Set(),
-    workflowGates: [],
-    deferredPushes: []
-  };
-  const concurrency = repositorySaveConcurrency(options);
-  for (const [index, wave] of waves.entries()) {
-    await runLimited(wave, concurrency, async (node) => {
-      try {
-        await saveOneRepository(node, options, state);
-      } catch (error) {
-        const existing = repositorySaveErrorDetails(error);
-        throw new RepositorySaveError(error instanceof Error ? error.message : String(error), {
-          exitCode: existing.exitCode,
-          details: {
-            ...existing.details ?? {},
-            partialFailure: {
-              message: `Treeseed save stopped while saving ${node.name}.`,
-              failingRepo: node.name,
-              phase: typeof existing.details?.phase === "string" ? existing.details.phase : null,
-              currentVersion: typeof node.packageJson?.version === "string" ? node.packageJson.version : null,
-              expectedTag: node.plannedTag,
-              tagState: node.plannedTag ? tagState(node.path, node.plannedTag) : null,
-              nextCommand: `treeseed resume ${options.workflowRunId ?? "<run-id>"}`,
-              repos: [...state.reports.entries()].filter(([id]) => id !== ".").map(([, report]) => report),
-              rootRepo: state.reports.get(".") ?? null,
-              error: error instanceof Error ? error.message : String(error)
-            }
-          }
-        });
-      }
-    });
-    const waveReports = wave.map((node) => state.reports.get(node.id) ?? createReport(node));
-    const allReports = [...state.reports.values()];
-    let waveGates;
-    try {
-      waveGates = await options.onWaveSaved?.({
-        index: index + 1,
-        nodes: wave,
-        reports: waveReports,
-        allReports,
-        rootRepo: state.reports.get(".") ?? null
-      });
-    } catch (error) {
-      const existing = repositorySaveErrorDetails(error);
-      const errorDetails = existing.details ?? (error && typeof error === "object" && "details" in error && error.details && typeof error.details === "object" ? error.details : void 0);
-      const errorExitCode = existing.exitCode ?? (error && typeof error === "object" && "exitCode" in error && typeof error.exitCode === "number" ? error.exitCode : void 0);
-      const gate = errorDetails?.gate;
-      const failingRepo = gate && typeof gate === "object" && "name" in gate && typeof gate.name === "string" ? gate.name : wave.map((node) => node.name).join(", ");
-      throw new RepositorySaveError(error instanceof Error ? error.message : String(error), {
-        exitCode: errorExitCode,
-        details: {
-          ...errorDetails ?? {},
-          partialFailure: {
-            message: `Treeseed save stopped while waiting for hosted gates after wave ${index + 1}.`,
-            failingRepo,
-            nextCommand: `treeseed resume ${options.workflowRunId ?? "<run-id>"}`,
-            repos: allReports.filter((report) => report.name !== "@treeseed/market"),
-            rootRepo: state.reports.get(".") ?? null,
-            error: error instanceof Error ? error.message : String(error)
-          }
-        }
-      });
-    }
-    if (Array.isArray(waveGates)) {
-      state.workflowGates.push(...waveGates);
-    }
-  }
-  await publishDeferredRepositoryPushes(options, state);
-  const rootNode = nodes.find((node) => node.id === ".") ?? allNodes.find((node) => node.id === ".");
-  const rootReport = rootNode ? state.reports.get(rootNode.id) ?? createReport(rootNode) : createReport({
-    id: ".",
-    name: "@treeseed/market",
-    path: gitRoot,
-    relativePath: ".",
-    kind: "project",
-    branch,
-    branchMode: "project-save",
-    packageJsonPath: null,
-    packageJson: null,
-    scripts: {},
-    remoteUrl: null,
-    dependencies: [],
-    dependents: [],
-    submoduleDependencies: [],
-    plannedVersion: null,
-    plannedTag: null,
-    plannedDependencySpec: null
-  });
-  const packageReports = nodes.filter((node) => node.id !== ".").sort(compareNodes).map((node) => state.reports.get(node.id) ?? createReport(node));
-  return {
-    mode,
-    branch,
-    scope,
-    repos: packageReports,
-    rootRepo: rootReport,
-    waves: waves.map((wave) => wave.map((node) => node.name)),
-    plannedVersions: Object.fromEntries(state.finalizedVersions.entries()),
-    workflowGates: state.workflowGates
-  };
-}
-function repositorySaveErrorDetails(error) {
-  if (error instanceof RepositorySaveError) {
-    return {
-      exitCode: error.exitCode,
-      details: error.details
-    };
-  }
-  return {
-    exitCode: void 0,
-    details: void 0
-  };
-}
-export {
-  applyPackageVersion,
-  discoverRepositorySaveNodes,
-  nextDevVersion,
-  planRepositorySave,
-  refreshAndValidateRootWorkspaceLockfileForSave,
-  repositorySaveErrorDetails,
-  repositorySaveWaves,
-  runRepositorySaveOrchestrator,
-  runStreamingCommand,
-  validateStandaloneGitDependencyLockfile
-};