@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-TRURQUBP.js

@@ -0,0 +1,1217 @@
+import {
+  assertNoPlanningStorageHold,
+  assertNoStorageDrift,
+  publishManagedChange,
+  recordManagedChange
+} from "./chunk-SNGM452K.js";
+import {
+  repositoryFromGitHubRemoteUrl
+} from "./chunk-BDPYFAB4.js";
+import {
+  getBucketByName
+} from "./chunk-V3KLVK7B.js";
+import {
+  refreshDefaultBranchTracking
+} from "./chunk-BAWJNMWF.js";
+import {
+  resolvePlanningContextForRoot
+} from "./chunk-BBPIILO2.js";
+import {
+  ManagedSyncBranchError,
+  describeManagedSyncBranchRefusal,
+  findEmbeddedHomePathRefusal,
+  formatManagedSyncBranchError,
+  isManagedSyncBranchError
+} from "./chunk-I7SCBHJN.js";
+import {
+  isSafeGitRemoteAndRef
+} from "./chunk-D2M2Y5ID.js";
+import {
+  resolveManagedSyncDefaultBranch
+} from "./chunk-XGU6PBO5.js";
+import {
+  GitExecError,
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  GIT_HOOK_COMMIT_TIMEOUT_MS,
+  PLANNING_GIT_NETWORK_TIMEOUT_MS
+} from "./chunk-I56TH7VM.js";
+import {
+  toRepoRelativePath
+} from "./chunk-STW7OFOA.js";
+import {
+  BUILD_DEFER_SYNC,
+  PUBLISH_OUTCOME_EXIT_CODES,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/planning/git-exec.ts
+var NETWORK_GIT_SUBCOMMANDS = /* @__PURE__ */ new Set(["fetch", "ls-remote", "pull", "push"]);
+async function runPlanningGit(args, options) {
+  const replayingRebase = args[0] === "rebase" && args[1] !== "--abort" && args[1] !== "--quit";
+  const networkTimeoutMs = NETWORK_GIT_SUBCOMMANDS.has(args[0] ?? "") ? PLANNING_GIT_NETWORK_TIMEOUT_MS : replayingRebase ? GIT_HOOK_COMMIT_TIMEOUT_MS : void 0;
+  try {
+    const result = await execGit(args, {
+      cwd: options.cwd,
+      ...options.input === void 0 ? {} : { input: options.input },
+      ...options.env ? { env: options.env } : {},
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : networkTimeoutMs !== void 0 ? { timeoutMs: networkTimeoutMs } : {}
+    });
+    if (options.reject !== false && result.exitCode !== 0) {
+      throw new Error(
+        `git ${args.join(" ")} failed with exit ${result.exitCode}: ${result.stderr}`
+      );
+    }
+    return result;
+  } catch (error) {
+    if (options.reject === false && error instanceof GitExecError) {
+      return {
+        exitCode: void 0,
+        stdout: "",
+        stderr: error.message,
+        ...error.timedOut ? { timedOut: true } : {}
+      };
+    }
+    throw error;
+  }
+}
+
+// src/planning/git-sync-publication-base.ts
+async function readManagedSyncPublicationBase(projectRoot, remote, remoteBranch) {
+  const head = await runPlanningGit(["rev-parse", "HEAD"], {
+    cwd: projectRoot,
+    reject: false
+  });
+  const preSyncHeadSha = head.exitCode === 0 ? head.stdout.trim() : "";
+  const remoteBranchResult = await runPlanningGit(
+    ["ls-remote", "--heads", "--", remote, `refs/heads/${remoteBranch}`],
+    { cwd: projectRoot, reject: false }
+  );
+  return {
+    preSyncHeadSha,
+    remoteBranchExists: remoteBranchResult.stdout.trim().length > 0,
+    remoteBranchResult
+  };
+}
+
+// src/planning/git-sync-staging.ts
+function splitNulTerminatedPaths(stdout) {
+  return stdout.split("\0").filter((entry) => entry.length > 0);
+}
+async function resolvePathsThisSyncWillStage(projectRoot, managedPaths, hadPreexistingStagedChanges) {
+  if (managedPaths.length === 0) {
+    return [];
+  }
+  if (!hadPreexistingStagedChanges) {
+    return [...managedPaths];
+  }
+  const alreadyStaged = new Set(await listStagedRelativePaths(projectRoot, managedPaths));
+  return managedPaths.filter((managedPath) => !alreadyStaged.has(managedPath));
+}
+async function unstageThisSyncPaths(projectRoot, paths) {
+  if (paths.length === 0) {
+    return;
+  }
+  await runPlanningGit(["reset", "--", ...paths], {
+    cwd: projectRoot,
+    reject: false
+  });
+}
+async function snapshotStagedIndexEntries(projectRoot, paths) {
+  if (paths.length === 0) {
+    return [];
+  }
+  const result = await runPlanningGit(["ls-files", "-s", "-z", "--", ...paths], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (result.exitCode !== 0 || !result.stdout) {
+    return [];
+  }
+  const entries = [];
+  for (const record of result.stdout.split("\0")) {
+    if (!record) continue;
+    const match = record.match(/^(\d{6}) ([0-9a-f]{40,64}) \d+\t(.+)$/);
+    if (!match?.[1] || !match[2] || !match[3]) continue;
+    entries.push({ mode: match[1], sha: match[2], path: match[3] });
+  }
+  return entries;
+}
+async function restoreStagedIndexEntries(projectRoot, entries) {
+  for (const entry of entries) {
+    await runPlanningGit(["update-index", "--cacheinfo", entry.mode, entry.sha, entry.path], {
+      cwd: projectRoot,
+      reject: false
+    });
+  }
+}
+async function captureManagedSyncStaging(projectRoot, managedPaths, hadPreexistingStagedChanges) {
+  const pathsThisSyncWillStage = await resolvePathsThisSyncWillStage(
+    projectRoot,
+    managedPaths,
+    hadPreexistingStagedChanges
+  );
+  return {
+    pathsThisSyncWillStage,
+    overlappingStagedSnapshots: await snapshotStagedIndexEntries(
+      projectRoot,
+      managedPaths.filter((managedPath) => !pathsThisSyncWillStage.includes(managedPath))
+    )
+  };
+}
+async function abandonManagedSyncStaging(projectRoot, state) {
+  await unstageThisSyncPaths(projectRoot, state.pathsStagedByThisSync);
+  await restoreStagedIndexEntries(projectRoot, state.overlappingStagedSnapshots);
+}
+async function listStagedRelativePaths(projectRoot, pathspecs) {
+  if (pathspecs.length === 0) {
+    return [];
+  }
+  const result = await runPlanningGit(
+    ["diff", "--cached", "--name-only", "-z", "--", ...pathspecs],
+    { cwd: projectRoot, reject: false }
+  );
+  return splitNulTerminatedPaths(result.stdout);
+}
+
+// src/planning/remote-sync-verify.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var DEFAULT_VERIFY_DELAYS_MS = [0, 2e3, 4e3];
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function resolveRemoteBranchSha(projectRoot, remote, remoteBranch, options = {}) {
+  if (!isSafeGitRemoteAndRef(remote, remoteBranch)) {
+    return "";
+  }
+  const ref = `refs/heads/${remoteBranch}`;
+  const lsRemote = await runPlanningGit(["ls-remote", "--heads", "--", remote, ref], {
+    cwd: projectRoot,
+    reject: false,
+    ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+  });
+  if (lsRemote.exitCode !== 0) {
+    return "";
+  }
+  const matches = lsRemote.stdout.trim().split(/\r?\n/).map((line) => line.trim().split(/\s+/)).filter(([, name]) => name === ref);
+  return matches.length === 1 ? matches[0]?.[0] ?? "" : "";
+}
+async function remoteContainsCommit(projectRoot, remote, remoteBranch, commitSha, options = {}) {
+  const remoteSha = await resolveRemoteBranchSha(projectRoot, remote, remoteBranch, options);
+  if (!remoteSha) {
+    return false;
+  }
+  if (remoteSha === commitSha) {
+    return true;
+  }
+  const ancestorCheck = await runPlanningGit(
+    ["merge-base", "--is-ancestor", commitSha, remoteSha],
+    {
+      cwd: projectRoot,
+      reject: false
+    }
+  );
+  return ancestorCheck.exitCode === 0;
+}
+async function remoteContainsPaths(projectRoot, remote, remoteBranch, relativePaths) {
+  const remoteRef = `${remote}/${remoteBranch}`;
+  for (const relativePath of relativePaths) {
+    const showResult = await runPlanningGit(["show", `${remoteRef}:${relativePath}`], {
+      cwd: projectRoot,
+      reject: false
+    });
+    if (showResult.exitCode !== 0) {
+      return { ok: false, missingPath: relativePath };
+    }
+  }
+  return { ok: true };
+}
+async function verifyRemoteSyncPush(options) {
+  const {
+    projectRoot,
+    remote,
+    remoteBranch,
+    relativePaths,
+    expectedCommitSha,
+    maxAttempts = 3,
+    verifyDelaysMs = DEFAULT_VERIFY_DELAYS_MS
+  } = options;
+  if (!expectedCommitSha) {
+    return { ok: false, reason: "missing expected commit SHA for remote verification" };
+  }
+  if (!isSafeGitRemoteAndRef(remote, remoteBranch)) {
+    return {
+      ok: false,
+      reason: "upstream remote or branch name is not a safe git identifier"
+    };
+  }
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const delayMs = verifyDelaysMs[attempt] ?? verifyDelaysMs.at(-1) ?? 0;
+    if (delayMs > 0) {
+      await sleep(delayMs);
+    }
+    const fetchResult = await runPlanningGit(["fetch", "--", remote, remoteBranch], {
+      cwd: projectRoot,
+      reject: false
+    });
+    if (fetchResult.exitCode !== 0) {
+      if (attempt === maxAttempts - 1) {
+        const fetchDetail = fetchResult.stderr?.split("\n").find((line) => line.trim().length > 0) ?? fetchResult.stdout?.split("\n").find((line) => line.trim().length > 0) ?? "fetch failed";
+        return {
+          ok: false,
+          reason: `remote verification fetch failed after ${maxAttempts} attempts: ${fetchDetail}`
+        };
+      }
+      continue;
+    }
+    const remoteSha = await resolveRemoteBranchSha(projectRoot, remote, remoteBranch);
+    if (!remoteSha) {
+      if (attempt === maxAttempts - 1) {
+        return {
+          ok: false,
+          reason: `remote branch ${remote}/${remoteBranch} not found after push`
+        };
+      }
+      continue;
+    }
+    const commitVisible = await remoteContainsCommit(
+      projectRoot,
+      remote,
+      remoteBranch,
+      expectedCommitSha
+    );
+    if (!commitVisible) {
+      if (attempt === maxAttempts - 1) {
+        return {
+          ok: false,
+          reason: `remote ${remote}/${remoteBranch} at ${remoteSha} does not contain pushed commit ${expectedCommitSha}`
+        };
+      }
+      continue;
+    }
+    if (relativePaths.length > 0) {
+      const pathCheck = await remoteContainsPaths(projectRoot, remote, remoteBranch, relativePaths);
+      if (!pathCheck.ok) {
+        if (attempt === maxAttempts - 1) {
+          return {
+            ok: false,
+            reason: `remote ${remote}/${remoteBranch} is missing synced path ${pathCheck.missingPath}`
+          };
+        }
+        continue;
+      }
+    }
+    return { ok: true, remoteSha };
+  }
+  return { ok: false, reason: "remote verification failed after retries" };
+}
+function isRefspecPushTopology(localBranch, remoteBranch) {
+  return localBranch.length > 0 && remoteBranch.length > 0 && localBranch !== remoteBranch;
+}
+async function filterExistingRelativePaths(projectRoot, relativePaths) {
+  const existingPaths = [];
+  for (const relativePath of relativePaths) {
+    try {
+      await fs.access(path.join(projectRoot, relativePath));
+      existingPaths.push(relativePath);
+    } catch {
+    }
+  }
+  return existingPaths;
+}
+
+// src/planning/git-sync-push.ts
+function isMissingRemoteError(output) {
+  return /does not appear to be a git repository|couldn't find remote ref|repository .* not found|no such remote/i.test(
+    output
+  );
+}
+function firstGitLine(output) {
+  return output?.split("\n").find((line) => line.trim().length > 0)?.trim() ?? "unknown";
+}
+async function resolveManagedSyncPushCandidate(projectRoot, expectedParentSha, allowedPaths) {
+  const headResult = await runPlanningGit(["rev-parse", "HEAD"], {
+    cwd: projectRoot,
+    reject: false
+  });
+  const candidateSha = headResult.exitCode === 0 ? headResult.stdout.trim() : "";
+  if (!candidateSha || !expectedParentSha) {
+    return {
+      ok: false,
+      reason: "could not resolve the managed sync candidate or its parent"
+    };
+  }
+  const parentResult = await runPlanningGit(["rev-parse", `${candidateSha}^`], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (parentResult.exitCode !== 0 || parentResult.stdout.trim() !== expectedParentSha) {
+    return {
+      ok: false,
+      reason: "the final candidate was not exactly one managed sync commit above the remote base"
+    };
+  }
+  const changedPathsResult = await runPlanningGit(
+    ["diff-tree", "--no-commit-id", "--name-only", "-r", "-z", candidateSha],
+    { cwd: projectRoot, reject: false }
+  );
+  const changedPaths = splitNulTerminatedPaths(changedPathsResult.stdout);
+  const allowedPathSet = new Set(allowedPaths);
+  if (changedPathsResult.exitCode !== 0 || changedPaths.length === 0 || changedPaths.some((changedPath) => !allowedPathSet.has(changedPath))) {
+    return {
+      ok: false,
+      reason: "the final candidate changed paths outside the managed sync scope"
+    };
+  }
+  return { ok: true, sha: candidateSha };
+}
+async function pushManagedCommitWithRetry(params) {
+  const { projectRoot, remote, remoteBranch, refspecTopology, preSyncHeadSha } = params;
+  const maxSyncAttempts = refspecTopology ? 1 : 3;
+  for (let attempt = 1; attempt <= maxSyncAttempts; attempt++) {
+    let expectedParentSha = preSyncHeadSha;
+    if (params.remoteBranchExists && !refspecTopology) {
+      const remoteHeadResult = await runPlanningGit(["rev-parse", "FETCH_HEAD"], {
+        cwd: projectRoot,
+        reject: false
+      });
+      expectedParentSha = remoteHeadResult.exitCode === 0 ? remoteHeadResult.stdout.trim() : "";
+      const rebaseResult = await runPlanningGit(["rebase", "FETCH_HEAD"], {
+        cwd: projectRoot,
+        reject: false
+      });
+      if (rebaseResult.exitCode !== 0) {
+        const rebaseStderr = rebaseResult.stderr ?? "";
+        const rebaseStdout = rebaseResult.stdout ?? "";
+        const rebaseOutputCombined = `${rebaseStderr}
+${rebaseStdout}`.toLowerCase();
+        const isConflict = rebaseOutputCombined.includes("conflict") || rebaseOutputCombined.includes("could not apply");
+        await runPlanningGit(["rebase", "--abort"], { cwd: projectRoot, reject: false });
+        const reason = isConflict ? "rebase conflicted (aborted rebase)" : `rebase failed: ${firstGitLine(rebaseStderr || rebaseStdout)}`;
+        return { kind: "local-only", message: `Committed locally but ${reason} - push skipped` };
+      }
+    }
+    const candidate = await resolveManagedSyncPushCandidate(
+      projectRoot,
+      expectedParentSha,
+      params.commitPaths
+    );
+    if (!candidate.ok) {
+      return {
+        kind: "local-only",
+        message: `Committed locally but ${candidate.reason} - push skipped`
+      };
+    }
+    const shouldSetUpstream = !params.hasUpstream || !params.remoteBranchExists;
+    const pushArgs = shouldSetUpstream ? ["push", "-u", "--", remote, `${candidate.sha}:refs/heads/${remoteBranch}`] : ["push", "--", remote, `${candidate.sha}:${remoteBranch}`];
+    await params.turn?.assertOwned();
+    const pushResult = await runPlanningGit(pushArgs, { cwd: projectRoot, reject: false });
+    if (pushResult.exitCode === 0) {
+      const verifyResult = await verifyRemoteSyncPush({
+        projectRoot,
+        remote,
+        remoteBranch,
+        relativePaths: await filterExistingRelativePaths(projectRoot, params.verifyPaths),
+        expectedCommitSha: candidate.sha
+      });
+      if (verifyResult.ok) return { kind: "synced" };
+      return {
+        kind: "unverified",
+        message: `Committed locally but remote verification failed: ${verifyResult.reason} - treat push as failed`
+      };
+    }
+    const pushOutput = `${pushResult.stderr ?? ""}
+${pushResult.stdout ?? ""}`;
+    const pushError = pushOutput.toLowerCase();
+    const isNonFastForward = pushError.includes("non-fast-forward") || pushError.includes("fetch first") || pushError.includes("failed to push some refs");
+    if (!isNonFastForward || attempt === maxSyncAttempts) {
+      return {
+        kind: "push-failed",
+        message: `Committed locally but push failed: ${firstGitLine(pushResult.stderr ?? pushResult.stdout)}`,
+        missingRemote: isMissingRemoteError(pushOutput)
+      };
+    }
+    const refreshedBoundary = await params.refreshBoundary();
+    if (!refreshedBoundary.ok) {
+      return {
+        kind: "local-only",
+        message: `Committed locally but ${refreshedBoundary.reason} - push skipped`
+      };
+    }
+  }
+  throw new Error("Managed sync retry loop exhausted without a terminal outcome");
+}
+
+// src/planning/storage/sync-dispatch.ts
+import path2 from "path";
+var ManagedStoragePathError = class extends Error {
+  paths;
+  constructor(paths) {
+    super(
+      `Managed item paths are not under the planning storage worktree; managed items never live in the code checkout under the git-branch backend: ${paths.join(", ")}`
+    );
+    this.name = "ManagedStoragePathError";
+    this.paths = paths;
+  }
+};
+function toManagedSyncOutcome(result) {
+  const status = {
+    published: "synced",
+    "local-only": "local-only",
+    pending: "unverified",
+    unverified: "unverified"
+  }[result.outcome];
+  const detail = [
+    result.outcome === "pending" ? "publication pending" : void 0,
+    result.reason,
+    result.pendingRef ? `candidate retained at ${result.pendingRef}` : void 0
+  ].filter((part) => Boolean(part));
+  const unpublished = result.outcome === "pending" || result.outcome === "unverified";
+  return {
+    outcome: { synced: result.outcome === "published", status },
+    exitCode: result.exitCode ?? PUBLISH_OUTCOME_EXIT_CODES[result.outcome],
+    publishOutcome: result.outcome,
+    ...detail.length > 0 ? { reason: detail.join("; ") } : {},
+    ...result.pendingRef ? { pendingRef: result.pendingRef } : {},
+    ...result.commitSha ? { commitSha: result.commitSha } : {},
+    localByPolicyPaths: result.localByPolicyPaths,
+    ...unpublished ? { pendingWarning: formatUnpublishedPublication(result) } : {}
+  };
+}
+function toDeferredSyncOutcome(result) {
+  return {
+    outcome: { synced: false, status: "skipped" },
+    exitCode: 0,
+    publishOutcome: result.outcome,
+    ...result.pendingRef ? { pendingRef: result.pendingRef } : {},
+    ...result.commitSha ? { commitSha: result.commitSha } : {},
+    localByPolicyPaths: result.localByPolicyPaths
+  };
+}
+function formatUnpublishedPublication(result) {
+  return [
+    `managed publication ${result.outcome}`,
+    result.reason?.replace(/[\s\p{Cc}]+/gu, " ").trim() || void 0,
+    result.pendingRef ? `candidate retained at ${result.pendingRef}` : void 0,
+    "publish it with: build plan storage sync"
+  ].filter((part) => Boolean(part)).join("; ");
+}
+function toStorageRelativePath(ctx, filePath) {
+  const absolute = path2.isAbsolute(filePath) ? filePath : path2.resolve(ctx.projectRoot, filePath);
+  const relative = toRepoRelativePath(ctx.storageRoot, absolute);
+  if (!relative || path2.isAbsolute(relative) || relative.split(path2.sep)[0] === "..") {
+    return void 0;
+  }
+  return relative.split(path2.sep).join("/");
+}
+function resolveStoragePaths(ctx, filePaths) {
+  const resolved = [];
+  const rejected = [];
+  for (const filePath of filePaths) {
+    const storagePath = toStorageRelativePath(ctx, filePath);
+    if (storagePath) {
+      if (!resolved.includes(storagePath)) resolved.push(storagePath);
+    } else {
+      rejected.push(filePath);
+    }
+  }
+  if (rejected.length > 0) {
+    throw new ManagedStoragePathError(rejected);
+  }
+  return resolved;
+}
+async function beginManagedSync(projectRoot) {
+  const ctx = resolvePlanningContextForRoot(projectRoot);
+  assertNoPlanningStorageHold();
+  await assertNoStorageDrift(ctx);
+  return ctx;
+}
+function codeCheckoutCarriesSharedBuckets(projectRoot) {
+  return resolvePlanningContextForRoot(projectRoot).backend !== "git-branch";
+}
+function backlogArchiveCopyPublishes(projectRoot) {
+  return !codeCheckoutCarriesSharedBuckets(projectRoot) && getBucketByName("backlog", projectRoot)?.archivePublished === true;
+}
+async function storageDriftRefusalAtPublication(projectRoot, remote) {
+  const ctx = resolvePlanningContextForRoot(projectRoot);
+  const refresh = await refreshDefaultBranchTracking(projectRoot, remote);
+  if (!refresh.ok) return { reason: refresh.reason, kind: "fetch-failed", blockCommit: false };
+  try {
+    await assertNoStorageDrift(ctx, { remote, defaultBranch: refresh.defaultBranch });
+    return void 0;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return { reason, kind: "storage-drift", blockCommit: true };
+  }
+}
+var UNPUBLISHED_EXIT_CODE = 2;
+function reportUnpublishedOutcome(translated, reportPending) {
+  if (!translated.pendingWarning) return;
+  if (reportPending === "dispatcher") {
+    process.stderr.write(`Warning: ${translated.pendingWarning}
+`);
+  }
+  const current = typeof process.exitCode === "number" ? process.exitCode : 0;
+  if (current < UNPUBLISHED_EXIT_CODE) process.exitCode = UNPUBLISHED_EXIT_CODE;
+}
+async function publishManagedSync(ctx, input) {
+  const storagePaths = resolveStoragePaths(ctx, input.paths);
+  const request = {
+    touchedPaths: storagePaths,
+    message: input.message,
+    ...input.verbose === void 0 ? {} : { verbose: input.verbose },
+    ...input.backlogGatePassed ? { backlogGatePassed: true } : {}
+  };
+  if (input.deferPublication) {
+    return { ...toDeferredSyncOutcome(await recordManagedChange(ctx, request)), storagePaths };
+  }
+  const result = await publishManagedChange(ctx, request);
+  const translated = toManagedSyncOutcome(result);
+  reportUnpublishedOutcome(translated, input.reportPending ?? "dispatcher");
+  return { ...translated, storagePaths };
+}
+async function dispatchManagedSync(projectRoot, input) {
+  const ctx = await beginManagedSync(projectRoot);
+  if (ctx.backend !== "git-branch") {
+    return { backend: ctx.backend, ctx, outcome: await input.legacySync() };
+  }
+  const published = await publishManagedSync(ctx, input);
+  return { backend: ctx.backend, ctx, ...published };
+}
+
+// src/planning/git-sync.ts
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import path3 from "path";
+import chalk from "chalk";
+
+// src/core/git/commit-subject.ts
+var MAX_BOOKKEEPING_SUBJECT_LENGTH = 62;
+function capCommitSubject(subject, max = MAX_BOOKKEEPING_SUBJECT_LENGTH) {
+  const points = Array.from(subject);
+  if (points.length <= max) return subject;
+  const cut = points.slice(0, max).join("");
+  const atWord = points[max] === " " ? cut : cut.slice(0, Math.max(cut.lastIndexOf(" "), 0));
+  return (atWord || cut).replace(/[\s.,;:]+$/u, "");
+}
+
+// src/planning/managed-commit-message.ts
+var CONVENTIONAL_SUBJECT = /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\([^)]*\))?!?: /u;
+var DOMAIN_SUBJECT = /^([a-z][a-z0-9-]*): (.+)$/u;
+function styleManagedCommitMessage(message, style) {
+  const newline = message.indexOf("\n");
+  const subject = newline === -1 ? message : message.slice(0, newline);
+  const rest = newline === -1 ? "" : message.slice(newline);
+  if (style === "plain" || CONVENTIONAL_SUBJECT.test(subject))
+    return capCommitSubject(subject) + rest;
+  const domain = DOMAIN_SUBJECT.exec(subject);
+  const topic = domain ? `${domain[1]} ${domain[2]}` : subject;
+  return capCommitSubject(`chore(planning): ${topic}`) + rest;
+}
+
+// src/planning/git-sync.ts
+var GENERATED_PLANNING_INDEX_CACHE_REL_PATH = ".build-project/planning/indexes";
+function isDeferSyncEnabled() {
+  return readEnv(BUILD_DEFER_SYNC).value ?? false;
+}
+var BACKLOG_SYNC_WORKING_BRANCH_PREFIX = "chore/backlog-sync-";
+async function assertManagedSyncBranch(projectRoot, branch) {
+  if (branch.startsWith(BACKLOG_SYNC_WORKING_BRANCH_PREFIX)) {
+    return;
+  }
+  const defaultBranch = await resolveManagedSyncDefaultBranch(projectRoot);
+  if (defaultBranch && branch === defaultBranch) return;
+  if (!defaultBranch) {
+    throw new ManagedSyncBranchError(
+      `Managed auto-sync refuses branch ${branch}; the repository default branch could not be established from origin/HEAD, main, or master`,
+      { branch, defaultBranch: "" }
+    );
+  }
+  throw new ManagedSyncBranchError(describeManagedSyncBranchRefusal(branch, defaultBranch), {
+    branch,
+    defaultBranch
+  });
+}
+async function verifyManagedSyncRebasePrecondition(projectRoot, managedCommitPaths) {
+  const unstaged = await runPlanningGit(["diff", "--quiet", "--"], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (unstaged.exitCode === 1) {
+    return { ok: false, reason: "rebase requires a clean worktree" };
+  }
+  if (unstaged.exitCode !== 0) {
+    return { ok: false, reason: "could not verify the clean worktree required for rebase" };
+  }
+  const staged = await runPlanningGit(["diff", "--cached", "--name-only", "-z"], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (staged.exitCode !== 0) {
+    return { ok: false, reason: "could not verify the staged paths required for rebase" };
+  }
+  const managedPathSet = new Set(managedCommitPaths);
+  const hasUnrelatedStagedPath = splitNulTerminatedPaths(staged.stdout).some(
+    (stagedPath) => !managedPathSet.has(stagedPath)
+  );
+  if (hasUnrelatedStagedPath) {
+    return { ok: false, reason: "rebase requires an index without unrelated staged changes" };
+  }
+  return { ok: true };
+}
+async function assertManagedSyncRepositoryState(projectRoot) {
+  for (const marker of ["rebase-merge", "rebase-apply"]) {
+    const markerResult = await runPlanningGit(["rev-parse", "--git-path", marker], {
+      cwd: projectRoot,
+      reject: false
+    });
+    if (markerResult.exitCode !== 0) continue;
+    const rawPath = markerResult.stdout.trim();
+    if (!rawPath) continue;
+    const markerPath = path3.isAbsolute(rawPath) ? rawPath : path3.resolve(projectRoot, rawPath);
+    if (existsSync(markerPath)) {
+      throw new ManagedSyncBranchError(
+        "Managed auto-sync refuses while a rebase is in progress; finish or abort the rebase first"
+      );
+    }
+  }
+}
+function isWithinRelPath(candidate, root) {
+  return candidate === root || candidate.startsWith(`${root}/`);
+}
+async function stageIgnoredTrackedPathsForSync(projectRoot, relRootPath) {
+  const trackedResult = await runPlanningGit(["ls-files", "-z", "--", relRootPath], {
+    cwd: projectRoot,
+    reject: false
+  });
+  if (trackedResult.exitCode !== 0 || trackedResult.stdout.length === 0) {
+    return [];
+  }
+  const trackedPaths = splitNulTerminatedPaths(trackedResult.stdout).filter(
+    (trackedPath) => isWithinRelPath(trackedPath, relRootPath)
+  );
+  if (trackedPaths.length === 0) {
+    return [];
+  }
+  const ignoredTrackedPaths = [];
+  for (const trackedPath of trackedPaths) {
+    const ignoreResult = await runPlanningGit(
+      ["check-ignore", "--no-index", "-q", "--", trackedPath],
+      {
+        cwd: projectRoot,
+        reject: false
+      }
+    );
+    if (ignoreResult.exitCode === 0) {
+      ignoredTrackedPaths.push(trackedPath);
+    }
+  }
+  if (ignoredTrackedPaths.length === 0) {
+    return [];
+  }
+  const rmResult = await runPlanningGit(
+    ["rm", "--cached", "--ignore-unmatch", "--", ...ignoredTrackedPaths],
+    {
+      cwd: projectRoot,
+      reject: false
+    }
+  );
+  if (rmResult.exitCode !== 0) {
+    return [];
+  }
+  return ignoredTrackedPaths;
+}
+async function stageGeneratedPlanningIndexCacheUntracking(projectRoot) {
+  return stageIgnoredTrackedPathsForSync(projectRoot, GENERATED_PLANNING_INDEX_CACHE_REL_PATH);
+}
+async function hasStagedChanges(projectRoot) {
+  const result = await runPlanningGit(["diff", "--cached", "--quiet"], {
+    cwd: projectRoot,
+    reject: false
+  });
+  return result.exitCode !== 0;
+}
+var ManagedSyncPathError = class extends Error {
+  detail;
+  paths;
+  /** Distinguishes a proven ignore refusal from a staging attempt outside Git. */
+  kind;
+  constructor(detail, paths, kind = "stage-failure") {
+    super(paths.length > 0 ? `${detail}: ${paths.join(", ")}` : detail);
+    this.name = "ManagedSyncPathError";
+    this.detail = detail;
+    this.paths = paths;
+    this.kind = kind;
+  }
+};
+function isRepositoryGitignoreSource(projectRoot, source) {
+  const resolvedSource = path3.resolve(projectRoot, source);
+  const relativeSource = path3.relative(path3.resolve(projectRoot), resolvedSource);
+  return source.length > 0 && path3.basename(resolvedSource) === ".gitignore" && relativeSource !== ".." && !relativeSource.startsWith(`..${path3.sep}`) && !path3.isAbsolute(relativeSource);
+}
+async function resolveSyncableManagedPaths(projectRoot, relativePaths) {
+  const resolved = { syncablePaths: [], unstageablePaths: [] };
+  for (const relativePath of relativePaths) {
+    const present = existsSync(path3.resolve(projectRoot, relativePath));
+    const probe = present ? { args: ["check-ignore", "-q", "--", relativePath], refusedExitCode: 0 } : { args: ["ls-files", "--error-unmatch", "--", relativePath], refusedExitCode: 1 };
+    const probed = await runPlanningGit(probe.args, { cwd: projectRoot, reject: false });
+    const refused = probed.exitCode === probe.refusedExitCode;
+    if (present && refused) {
+      const winningRule = await runPlanningGit(["check-ignore", "--stdin", "-v", "-z"], {
+        cwd: projectRoot,
+        input: `${relativePath}\0`,
+        reject: false
+      });
+      const source = winningRule.stdout.split("\0")[0] ?? "";
+      if (winningRule.exitCode !== 0 || !isRepositoryGitignoreSource(projectRoot, source)) {
+        throw new ManagedSyncPathError(
+          "Required managed paths are unexpectedly ignored outside repository .gitignore rules",
+          [relativePath],
+          "unexpected-ignore"
+        );
+      }
+    }
+    (refused ? resolved.unstageablePaths : resolved.syncablePaths).push(relativePath);
+  }
+  return resolved;
+}
+async function addManagedSyncPaths(projectRoot, paths) {
+  if (paths.length === 0) return;
+  const added = await runPlanningGit(["add", "--", ...paths], { cwd: projectRoot, reject: false });
+  if (added.exitCode !== 0) {
+    throw new ManagedSyncPathError("git add failed for managed paths", paths);
+  }
+}
+async function stageManagedSyncPaths(projectRoot, relativePaths, hadPreexistingStagedChanges) {
+  const captured = await captureManagedSyncStaging(
+    projectRoot,
+    relativePaths,
+    hadPreexistingStagedChanges
+  );
+  await addManagedSyncPaths(projectRoot, relativePaths);
+  const generatedCacheUntrackedPaths = hadPreexistingStagedChanges ? [] : await stageGeneratedPlanningIndexCacheUntracking(projectRoot);
+  return {
+    stagingState: {
+      overlappingStagedSnapshots: captured.overlappingStagedSnapshots,
+      pathsStagedByThisSync: [...captured.pathsThisSyncWillStage, ...generatedCacheUntrackedPaths]
+    },
+    generatedCacheUntrackedPaths
+  };
+}
+async function verifyManagedSyncPushBoundary(projectRoot, remote, remoteBranch, preSyncHeadSha, remoteBranchExists, commitContext) {
+  if (!preSyncHeadSha) {
+    return {
+      ok: false,
+      reason: "could not resolve the pre-sync commit",
+      kind: "unresolved-base",
+      blockCommit: false
+    };
+  }
+  if (!isSafeGitRemoteAndRef(remote, remoteBranchExists ? remoteBranch : "HEAD")) {
+    return {
+      ok: false,
+      reason: "upstream remote or branch name is not a safe git identifier",
+      kind: "unresolved-base",
+      blockCommit: false
+    };
+  }
+  const drift = await storageDriftRefusalAtPublication(projectRoot, remote);
+  if (drift) return { ok: false, ...drift };
+  const fetchResult = await runPlanningGit(
+    remoteBranchExists ? ["fetch", "--", remote, remoteBranch] : ["fetch", "--", remote],
+    {
+      cwd: projectRoot,
+      reject: false
+    }
+  );
+  if (fetchResult.exitCode !== 0) {
+    return {
+      ok: false,
+      reason: `fetch failed: ${firstGitLine(fetchResult.stderr ?? fetchResult.stdout)}`,
+      kind: "fetch-failed",
+      blockCommit: false
+    };
+  }
+  const ancestryResult = remoteBranchExists ? await runPlanningGit(["merge-base", "--is-ancestor", preSyncHeadSha, "FETCH_HEAD"], {
+    cwd: projectRoot,
+    reject: false
+  }) : await runPlanningGit(
+    [
+      "for-each-ref",
+      "--format=%(refname)",
+      "--contains",
+      preSyncHeadSha,
+      `refs/remotes/${remote}/`
+    ],
+    { cwd: projectRoot, reject: false }
+  );
+  const baseIsPublished = ancestryResult.exitCode === 0 && (remoteBranchExists || ancestryResult.stdout.trim().length > 0);
+  if (!baseIsPublished) {
+    return {
+      ok: false,
+      reason: "the local branch already contained commits not present on the remote before managed sync",
+      kind: "unpublished-base",
+      blockCommit: true
+    };
+  }
+  if (remoteBranchExists && commitContext && !isRefspecPushTopology(commitContext.branch, remoteBranch)) {
+    const readiness = await verifyManagedSyncRebasePrecondition(projectRoot, commitContext.paths);
+    if (!readiness.ok) {
+      return { ...readiness, kind: "rebase-precondition", blockCommit: true };
+    }
+  }
+  return { ok: true };
+}
+async function readManagedSyncTarget(projectRoot, targetBranch) {
+  const git = (args) => runPlanningGit(args, { cwd: projectRoot, reject: false });
+  let current = await git(["branch", "--show-current"]);
+  if (!current.stdout.trim()) current = await git(["rev-parse", "--abbrev-ref", "HEAD"]);
+  const branch = current.exitCode === 0 ? current.stdout.trim() : "";
+  const upstream = await git(["rev-parse", "--abbrev-ref", `${branch}@{upstream}`]);
+  const hasUpstream = upstream.exitCode === 0;
+  const slash = upstream.stdout.trim().indexOf("/");
+  const remote = !targetBranch && hasUpstream && slash > 0 ? upstream.stdout.trim().slice(0, slash) : "origin";
+  const remoteBranch = targetBranch ?? (hasUpstream && slash > 0 ? upstream.stdout.trim().slice(slash + 1) : branch);
+  return { branch, remote, remoteBranch, hasUpstream };
+}
+var ManagedPublicationAcquisitionError = class extends Error {
+  outcome = { synced: false, status: "staged" };
+  constructor(cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Not committed: local work preserved; sync incomplete (${detail})`, { cause });
+    this.name = "ManagedPublicationAcquisitionError";
+  }
+};
+async function prepareManagedSyncPublication(projectRoot, options = {}) {
+  const target = await readManagedSyncTarget(projectRoot, options.targetBranch);
+  if (options.prepareOnly || !isSafeGitRemoteAndRef(target.remote, target.remoteBranch))
+    return target;
+  const readDestination = async () => {
+    const result = await runPlanningGit(["remote", "get-url", "--push", "--all", target.remote], {
+      cwd: projectRoot,
+      reject: false
+    });
+    if (result.exitCode !== 0 && !isMissingRemoteError(result.stderr))
+      throw new Error("Cannot resolve managed publication destination");
+    const urls = result.stdout.trim().split(/\r?\n/).filter(Boolean);
+    const repositories = urls.map(repositoryFromGitHubRemoteUrl);
+    if (urls.length > 1 && repositories.some(Boolean))
+      throw new Error("Managed publication requires one GitHub push destination");
+    return repositories[0]?.toLowerCase();
+  };
+  const repository = await readDestination();
+  if (!repository) return target;
+  if (!options.targetBranch) await assertManagedSyncBranch(projectRoot, target.branch);
+  const { acquirePublicationTurn } = await import("./publication-turn-S42RZTQF.js");
+  const turn = await acquirePublicationTurn({
+    repository,
+    targetBranch: target.remoteBranch,
+    ownerId: options.ownerId ?? `managed-sync:${randomUUID()}`,
+    recover: Boolean(options.ownerId)
+  }).catch((cause) => {
+    throw new ManagedPublicationAcquisitionError(cause);
+  });
+  try {
+    await turn.assertOwned();
+    const fresh = await readManagedSyncTarget(projectRoot, options.targetBranch);
+    if (JSON.stringify(fresh) !== JSON.stringify(target) || await readDestination() !== repository)
+      throw new Error("Managed publication destination changed while waiting; retry sync");
+    return { ...fresh, turn };
+  } catch (error) {
+    await turn.release();
+    throw error;
+  }
+}
+async function syncPlanningFiles(projectRoot, filePaths, commitMessage, options = {}) {
+  if (options.deferPublication && codeCheckoutCarriesSharedBuckets(projectRoot)) {
+    return { synced: false, status: "skipped" };
+  }
+  const dispatched = await dispatchManagedSync(projectRoot, {
+    paths: filePaths,
+    message: commitMessage,
+    verbose: options.silent !== true,
+    ...options.deferPublication ? { deferPublication: true } : {},
+    legacySync: () => syncPlanningFilesInCheckout(projectRoot, filePaths, commitMessage, options)
+  });
+  return dispatched.outcome;
+}
+async function syncPlanningFilesInCheckout(projectRoot, filePaths, commitMessage, options) {
+  const emitWarning = (message) => {
+    if (options.warningsToStderr) {
+      console.error(chalk.yellow(`  ${message}`));
+    } else if (!options.silent) {
+      console.log(chalk.yellow(`  ${message}`));
+    }
+  };
+  const warnOrThrow = (message) => {
+    if (options.strict) {
+      throw new Error(message);
+    }
+    emitWarning(message);
+  };
+  const warnOrThrowRemoteSync = (message) => {
+    if (options.strict && !options.allowPushFailure) {
+      throw new Error(message);
+    }
+    emitWarning(message);
+  };
+  let turn;
+  const stagingState = {
+    pathsStagedByThisSync: [],
+    overlappingStagedSnapshots: []
+  };
+  try {
+    const relativePaths = [
+      ...new Set(filePaths.map((fp) => toRepoRelativePath(projectRoot, fp)))
+    ].filter((fp) => fp.length > 0);
+    if (relativePaths.length === 0) {
+      if (options.strict && options.requireStagedChanges) {
+        throw new Error("Sync made no staged changes: no managed paths were provided");
+      }
+      return { synced: false, status: "skipped" };
+    }
+    const publication = await prepareManagedSyncPublication(projectRoot);
+    turn = publication.turn;
+    const { branch, remote, remoteBranch, hasUpstream } = publication;
+    await assertManagedSyncRepositoryState(projectRoot);
+    const { syncablePaths } = await resolveSyncableManagedPaths(projectRoot, relativePaths);
+    const homePathRefusal = await findEmbeddedHomePathRefusal(projectRoot, syncablePaths);
+    if (homePathRefusal) {
+      warnOrThrow(homePathRefusal);
+      return { synced: false, status: "skipped" };
+    }
+    const hadPreexistingStagedChanges = await hasStagedChanges(projectRoot);
+    const capturedStaging = await captureManagedSyncStaging(
+      projectRoot,
+      syncablePaths,
+      hadPreexistingStagedChanges
+    );
+    const pathsThisSyncWillStage = capturedStaging.pathsThisSyncWillStage;
+    stagingState.overlappingStagedSnapshots = capturedStaging.overlappingStagedSnapshots;
+    const generatedCacheUntrackedPaths = hadPreexistingStagedChanges ? [] : await stageGeneratedPlanningIndexCacheUntracking(projectRoot);
+    const canCommitAllStaged = generatedCacheUntrackedPaths.length > 0;
+    const commitPaths = [...syncablePaths, ...generatedCacheUntrackedPaths];
+    const commitManagedPaths = async () => {
+      await turn?.assertOwned();
+      const { resolveGitMessageStyle } = await import("./git-message-style-KCXGMTDT.js");
+      const message = styleManagedCommitMessage(commitMessage, resolveGitMessageStyle(projectRoot));
+      return runPlanningGit(
+        canCommitAllStaged ? ["commit", "-m", message] : ["commit", "-m", message, "--", ...commitPaths],
+        { cwd: projectRoot, reject: false, timeoutMs: GIT_HOOK_COMMIT_TIMEOUT_MS }
+      );
+    };
+    if (commitPaths.length === 0) {
+      if (options.strict && options.requireStagedChanges) {
+        throw new Error(
+          `Sync made no staged changes for ignored paths: ${relativePaths.join(", ")}`
+        );
+      }
+      return { synced: false, status: "skipped" };
+    }
+    await addManagedSyncPaths(projectRoot, syncablePaths);
+    stagingState.pathsStagedByThisSync = [
+      ...pathsThisSyncWillStage,
+      ...generatedCacheUntrackedPaths
+    ];
+    const diffResult = await runPlanningGit(
+      canCommitAllStaged ? ["diff", "--cached", "--quiet"] : ["diff", "--cached", "--quiet", "--", ...commitPaths],
+      {
+        cwd: projectRoot,
+        reject: false
+      }
+    );
+    if (diffResult.exitCode === 0) {
+      if (options.strict && options.requireStagedChanges) {
+        throw new Error(`Sync made no staged changes for: ${commitPaths.join(", ")}`);
+      }
+      return { synced: false, status: "skipped" };
+    }
+    if (!branch || branch === "HEAD") {
+      throw new ManagedSyncBranchError(
+        "Managed auto-sync refuses a detached HEAD; check out an eligible branch first"
+      );
+    }
+    await assertManagedSyncBranch(projectRoot, branch);
+    if (!isSafeGitRemoteAndRef(remote, remoteBranch)) {
+      const unsafeCommit = await commitManagedPaths();
+      if (unsafeCommit.exitCode !== 0) {
+        warnOrThrow(`Commit failed: ${unsafeCommit.stderr?.split("\n")[0] ?? "unknown"}`);
+        return { synced: false, status: "failed" };
+      }
+      warnOrThrowRemoteSync(
+        "Committed locally but upstream remote or branch name is not a safe git identifier - push skipped"
+      );
+      return { synced: false, status: "local-only" };
+    }
+    const { preSyncHeadSha, remoteBranchResult, remoteBranchExists } = await readManagedSyncPublicationBase(projectRoot, remote, remoteBranch);
+    if (remoteBranchResult.exitCode !== 0 && isMissingRemoteError(`${remoteBranchResult.stderr ?? ""}
+${remoteBranchResult.stdout ?? ""}`)) {
+      const offlineCommit = await commitManagedPaths();
+      if (offlineCommit.exitCode !== 0) {
+        warnOrThrow(`Commit failed: ${offlineCommit.stderr?.split("\n")[0] ?? "unknown"}`);
+        return { synced: false, status: "failed" };
+      }
+      warnOrThrowRemoteSync("Committed locally; no remote repository configured - push skipped");
+      return offlineOutcome(await isRemoteConfigured(projectRoot, remote));
+    }
+    const pushBoundary = await verifyManagedSyncPushBoundary(
+      projectRoot,
+      remote,
+      remoteBranch,
+      preSyncHeadSha,
+      remoteBranchExists,
+      { branch, paths: commitPaths }
+    );
+    if (!pushBoundary.ok && pushBoundary.blockCommit) {
+      warnOrThrowRemoteSync(
+        `Not committed: ${pushBoundary.reason} - managed changes left staged, push skipped`
+      );
+      return { synced: false, status: "staged" };
+    }
+    const refspecTopology = isRefspecPushTopology(branch, remoteBranch);
+    const commitResult = await commitManagedPaths();
+    if (commitResult.exitCode !== 0) {
+      warnOrThrow(`Commit failed: ${commitResult.stderr?.split("\n")[0] ?? "unknown"}`);
+      return { synced: false, status: "failed" };
+    }
+    if (!pushBoundary.ok) {
+      warnOrThrowRemoteSync(`Committed locally but ${pushBoundary.reason} - push skipped`);
+      return { synced: false, status: "local-only" };
+    }
+    const pushed = await pushManagedCommitWithRetry({
+      projectRoot,
+      remote,
+      remoteBranch,
+      hasUpstream,
+      remoteBranchExists,
+      refspecTopology,
+      preSyncHeadSha,
+      commitPaths,
+      verifyPaths: syncablePaths,
+      turn,
+      refreshBoundary: () => verifyManagedSyncPushBoundary(projectRoot, remote, remoteBranch, preSyncHeadSha, true)
+    });
+    if (pushed.kind === "synced") {
+      if (!options.silent) {
+        console.log(chalk.gray("  Synced to remote"));
+      }
+      return { synced: true, status: "synced" };
+    }
+    if (pushed.kind === "push-failed" && pushed.missingRemote) {
+      warnOrThrowRemoteSync("Committed locally; no remote repository configured - push skipped");
+      return offlineOutcome(await isRemoteConfigured(projectRoot, remote));
+    }
+    warnOrThrowRemoteSync(pushed.message);
+    return { synced: false, status: pushed.kind === "unverified" ? "unverified" : "local-only" };
+  } catch (error) {
+    if (error instanceof ManagedPublicationAcquisitionError && !options.strict) {
+      emitWarning(error.message);
+      return error.outcome;
+    }
+    if (isManagedSyncBranchError(error)) {
+      await abandonManagedSyncStaging(projectRoot, stagingState);
+      throw error;
+    }
+    if (options.strict || error instanceof ManagedSyncPathError && (error.kind === "unexpected-ignore" || await isInsideGitWorkTree(projectRoot))) {
+      throw error;
+    }
+    emitWarning(`Auto-sync failed: ${error.message?.split("\n")[0] ?? "unknown error"}`);
+    return { synced: false, status: "failed" };
+  } finally {
+    await turn?.release();
+  }
+}
+async function isRemoteConfigured(projectRoot, remote) {
+  const result = await runPlanningGit(["config", "--get", `remote.${remote}.url`], {
+    cwd: projectRoot,
+    reject: false
+  });
+  return result.exitCode === 0 && result.stdout.trim().length > 0;
+}
+function offlineOutcome(remoteConfigured) {
+  return remoteConfigured ? { synced: false, status: "local-only" } : { synced: false, status: "local-only", noRemote: true };
+}
+async function isInsideGitWorkTree(projectRoot) {
+  const result = await runPlanningGit(["rev-parse", "--is-inside-work-tree"], {
+    cwd: projectRoot,
+    reject: false
+  }).catch(() => void 0);
+  return result?.exitCode === 0 && result.stdout.trim() === "true";
+}
+var CHECKOUT_UNPUBLISHED_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "local-only",
+  "staged",
+  "unverified"
+]);
+async function syncManagedItemFiles(projectRoot, filePaths, commitMessage, options = {}) {
+  if (options.sync === false) {
+    return { synced: false };
+  }
+  const deferred = isDeferSyncEnabled();
+  if (deferred && codeCheckoutCarriesSharedBuckets(projectRoot)) {
+    return { synced: false };
+  }
+  try {
+    const dispatched = await dispatchManagedSync(projectRoot, {
+      paths: filePaths,
+      message: commitMessage,
+      verbose: options.silent !== true,
+      ...deferred ? { deferPublication: true } : {},
+      legacySync: () => syncPlanningFilesInCheckout(projectRoot, filePaths, commitMessage, {
+        silent: options.silent ?? false,
+        warningsToStderr: options.warningsToStderr ?? false
+      })
+    });
+    if (dispatched.reason && !dispatched.outcome.synced) {
+      const message = `Managed publication ${dispatched.outcome.status}: ${dispatched.reason}`;
+      if (options.warningsToStderr) console.error(chalk.yellow(`  ${message}`));
+      else if (!options.silent) console.log(chalk.yellow(`  ${message}`));
+    }
+    const unpublished = dispatched.backend !== "git-branch" && !dispatched.outcome.noRemote && CHECKOUT_UNPUBLISHED_STATUSES.has(dispatched.outcome.status) && await isInsideGitWorkTree(projectRoot);
+    return unpublished ? { synced: dispatched.outcome.synced, unpublished: true } : { synced: dispatched.outcome.synced };
+  } catch (error) {
+    if (!isManagedSyncBranchError(error)) {
+      throw error;
+    }
+    if (options.warningsToStderr) {
+      console.error(chalk.yellow(`  ${formatManagedSyncBranchError(error)}`));
+    } else if (!options.silent) {
+      console.log(chalk.yellow(`  ${formatManagedSyncBranchError(error)}`));
+    }
+    return { synced: false, syncStatus: "refused-branch" };
+  }
+}
+
+export {
+  runPlanningGit,
+  readManagedSyncPublicationBase,
+  abandonManagedSyncStaging,
+  verifyRemoteSyncPush,
+  isRefspecPushTopology,
+  isMissingRemoteError,
+  resolveManagedSyncPushCandidate,
+  pushManagedCommitWithRetry,
+  capCommitSubject,
+  toStorageRelativePath,
+  beginManagedSync,
+  codeCheckoutCarriesSharedBuckets,
+  backlogArchiveCopyPublishes,
+  publishManagedSync,
+  isDeferSyncEnabled,
+  assertManagedSyncBranch,
+  assertManagedSyncRepositoryState,
+  hasStagedChanges,
+  ManagedSyncPathError,
+  resolveSyncableManagedPaths,
+  stageManagedSyncPaths,
+  verifyManagedSyncPushBoundary,
+  ManagedPublicationAcquisitionError,
+  prepareManagedSyncPublication,
+  syncPlanningFiles,
+  isInsideGitWorkTree,
+  syncManagedItemFiles
+};
+//# sourceMappingURL=chunk-TRURQUBP.js.map