@ricsam/r5d-worker 0.0.36 → 0.0.37

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "type": "commonjs"
 }

package/dist/cjs/workspace-sync.cjs

@@ -0,0 +1,652 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_sync_exports = {};
+__export(workspace_sync_exports, {
+  MAX_WORKSPACE_SYNC_DIFF_BYTES: () => MAX_WORKSPACE_SYNC_DIFF_BYTES,
+  WORKSPACE_BRANCH: () => WORKSPACE_BRANCH,
+  WORKSPACE_PERIODIC_SCAN_INTERVAL_MS: () => WORKSPACE_PERIODIC_SCAN_INTERVAL_MS,
+  WorkspaceSyncSingleFlight: () => WorkspaceSyncSingleFlight,
+  calculateWorkspaceDiffFingerprint: () => calculateWorkspaceDiffFingerprint,
+  encodeWorkspaceBranch: () => encodeWorkspaceBranch,
+  mirrorShadowWorkspaceToVisible: () => mirrorShadowWorkspaceToVisible,
+  mirrorVisibleWorkspaceToShadow: () => mirrorVisibleWorkspaceToShadow,
+  synchronizeWorkspace: () => synchronizeWorkspace,
+  visibleProjectBranchPath: () => visibleProjectBranchPath,
+  workspacePlansRelativePath: () => workspacePlansRelativePath,
+  workspaceProjectBranchRelativePath: () => workspaceProjectBranchRelativePath
+});
+module.exports = __toCommonJS(workspace_sync_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const WORKSPACE_BRANCH = "main";
+const MAX_WORKSPACE_SYNC_DIFF_BYTES = 5 * 1024 * 1024;
+const WORKSPACE_PERIODIC_SCAN_INTERVAL_MS = 5e3;
+const MAX_REPORTED_WORKSPACE_PATHS = 2e3;
+const MAX_REPORTED_WORKSPACE_STATUS_BYTES = 256 * 1024;
+const MAX_MIRROR_COMPARISON_CACHE_ENTRIES = 2e5;
+const MIRROR_COMPARE_BUFFER_BYTES = 64 * 1024;
+const mirrorComparisonCache = /* @__PURE__ */ new Map();
+function gitArgs(input, args) {
+  return input.authHeader ? ["git", "-c", `http.extraHeader=${input.authHeader}`, ...args] : ["git", ...args];
+}
+function runGitResult(input, cwd, args) {
+  const result = Bun.spawnSync(gitArgs(input, args), {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0"
+    }
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString().trim(),
+    stderr: result.stderr.toString().trim()
+  };
+}
+function runGit(input, cwd, args, action) {
+  const result = runGitResult(input, cwd, args);
+  if (result.exitCode !== 0) {
+    throw new Error(`${action}: ${result.stderr || result.stdout || `git exited ${result.exitCode}`}`);
+  }
+  return result.stdout;
+}
+function tryGit(input, cwd, args) {
+  return runGitResult(input, cwd, args).exitCode === 0;
+}
+function encodeWorkspaceBranch(branchName) {
+  return encodeURIComponent(branchName);
+}
+function workspaceProjectBranchRelativePath(projectId, branchName) {
+  return import_node_path.default.posix.join("projects", projectId, "branches", encodeWorkspaceBranch(branchName));
+}
+function workspacePlansRelativePath(projectId, branchName) {
+  return import_node_path.default.posix.join("plans", projectId, encodeWorkspaceBranch(branchName));
+}
+function visibleProjectBranchPath(projectsRoot, manifest, branchName) {
+  return import_node_path.default.join(projectsRoot, manifest.repoSlug || manifest.projectId, branchName);
+}
+function localPlansBranchPath(plansRoot, projectId, branchName) {
+  return import_node_path.default.join(plansRoot, projectId, branchName);
+}
+function assertInside(root, candidate, label) {
+  const resolvedRoot = import_node_path.default.resolve(root);
+  const resolvedCandidate = import_node_path.default.resolve(candidate);
+  const relative = import_node_path.default.relative(resolvedRoot, resolvedCandidate);
+  if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+    throw new Error(`${label} escapes its managed root: ${candidate}`);
+  }
+}
+function listGitEligibleFiles(checkoutPath) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(checkoutPath, ".git"))) {
+    return [];
+  }
+  const result = Bun.spawnSync(["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", "."], {
+    cwd: checkoutPath,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`inspect eligible project files: ${result.stderr.toString().trim() || `git exited ${result.exitCode}`}`);
+  }
+  return result.stdout.toString().split("\0").filter((entry) => entry.length > 0 && entry !== ".git" && !entry.startsWith(".git/")).filter((entry) => {
+    try {
+      const stat = import_node_fs.default.lstatSync(import_node_path.default.join(checkoutPath, ...entry.split("/")));
+      return stat.isFile() || stat.isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }).sort();
+}
+function listShadowTrackedFiles(input, relativeRoot) {
+  const normalizedRoot = relativeRoot.split(import_node_path.default.sep).join("/").replace(/^\/+|\/+$/g, "");
+  const output = runGit(input, input.shadowRoot, ["ls-files", "-z", "--cached", "--", normalizedRoot], "list canonical workspace files");
+  const prefix = `${normalizedRoot}/`;
+  return output.split("\0").filter((entry) => entry.startsWith(prefix)).map((entry) => entry.slice(prefix.length)).filter(Boolean).sort();
+}
+function listFilesRecursively(root, filter) {
+  if (!import_node_fs.default.existsSync(root)) return [];
+  const files = [];
+  const visit = (current, relativeDir) => {
+    for (const entry of import_node_fs.default.readdirSync(current, { withFileTypes: true })) {
+      if (entry.name === ".git") continue;
+      const relativePath = relativeDir ? import_node_path.default.posix.join(relativeDir, entry.name) : entry.name;
+      const absolutePath = import_node_path.default.join(current, entry.name);
+      if (entry.isDirectory()) {
+        visit(absolutePath, relativePath);
+      } else if (!filter || filter(relativePath)) {
+        files.push(relativePath);
+      }
+    }
+  };
+  visit(root, "");
+  return files.sort();
+}
+function removeEmptyDirectories(root) {
+  if (!import_node_fs.default.existsSync(root)) return;
+  const visit = (current) => {
+    let empty = true;
+    for (const entry of import_node_fs.default.readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = import_node_path.default.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (!visit(absolutePath)) empty = false;
+      } else {
+        empty = false;
+      }
+    }
+    if (empty && current !== root) import_node_fs.default.rmdirSync(current);
+    return empty;
+  };
+  visit(root);
+}
+function copyEntry(sourceRoot, targetRoot, relativePath) {
+  const sourcePath = import_node_path.default.resolve(sourceRoot, ...relativePath.split("/"));
+  const targetPath = import_node_path.default.resolve(targetRoot, ...relativePath.split("/"));
+  assertInside(sourceRoot, sourcePath, "Workspace source path");
+  assertInside(targetRoot, targetPath, "Workspace target path");
+  const stat = import_node_fs.default.lstatSync(sourcePath);
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(targetPath), { recursive: true });
+  import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
+  if (stat.isSymbolicLink()) {
+    import_node_fs.default.symlinkSync(import_node_fs.default.readlinkSync(sourcePath), targetPath);
+    return;
+  }
+  if (stat.isFile()) {
+    import_node_fs.default.copyFileSync(sourcePath, targetPath);
+    import_node_fs.default.chmodSync(targetPath, stat.mode);
+  }
+}
+function entrySignature(stat) {
+  return [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
+}
+function regularFilesEqual(sourcePath, targetPath, size) {
+  const sourceFd = import_node_fs.default.openSync(sourcePath, "r");
+  const targetFd = import_node_fs.default.openSync(targetPath, "r");
+  const sourceBuffer = Buffer.allocUnsafe(Math.min(MIRROR_COMPARE_BUFFER_BYTES, Math.max(1, size)));
+  const targetBuffer = Buffer.allocUnsafe(sourceBuffer.length);
+  try {
+    let offset = 0;
+    while (offset < size) {
+      const length = Math.min(sourceBuffer.length, size - offset);
+      const sourceBytes = import_node_fs.default.readSync(sourceFd, sourceBuffer, 0, length, offset);
+      const targetBytes = import_node_fs.default.readSync(targetFd, targetBuffer, 0, length, offset);
+      if (sourceBytes === 0 || targetBytes === 0 || sourceBytes !== targetBytes || !sourceBuffer.subarray(0, sourceBytes).equals(targetBuffer.subarray(0, targetBytes))) {
+        return false;
+      }
+      offset += sourceBytes;
+    }
+    return true;
+  } finally {
+    import_node_fs.default.closeSync(sourceFd);
+    import_node_fs.default.closeSync(targetFd);
+  }
+}
+function entriesEqual(sourcePath, targetPath) {
+  let sourceStat;
+  let targetStat;
+  try {
+    sourceStat = import_node_fs.default.lstatSync(sourcePath);
+    targetStat = import_node_fs.default.lstatSync(targetPath);
+  } catch {
+    return false;
+  }
+  const cacheKey = `${sourcePath}\0${targetPath}`;
+  const signature = `${entrySignature(sourceStat)}\0${entrySignature(targetStat)}`;
+  if (mirrorComparisonCache.get(cacheKey) === signature) return true;
+  let equal = false;
+  if (sourceStat.isSymbolicLink() && targetStat.isSymbolicLink()) {
+    equal = import_node_fs.default.readlinkSync(sourcePath) === import_node_fs.default.readlinkSync(targetPath);
+  } else if (sourceStat.isFile() && targetStat.isFile()) {
+    equal = sourceStat.size === targetStat.size && (sourceStat.mode & 73) === (targetStat.mode & 73) && regularFilesEqual(sourcePath, targetPath, sourceStat.size);
+  }
+  if (equal) {
+    if (mirrorComparisonCache.size >= MAX_MIRROR_COMPARISON_CACHE_ENTRIES) mirrorComparisonCache.clear();
+    mirrorComparisonCache.set(cacheKey, signature);
+  } else {
+    mirrorComparisonCache.delete(cacheKey);
+  }
+  return equal;
+}
+function mirrorFileSet(sourceRoot, targetRoot, sourceFiles, targetFiles) {
+  import_node_fs.default.mkdirSync(targetRoot, { recursive: true });
+  const sourceSet = new Set(sourceFiles);
+  for (const relativePath of targetFiles) {
+    if (sourceSet.has(relativePath)) continue;
+    const targetPath = import_node_path.default.resolve(targetRoot, ...relativePath.split("/"));
+    assertInside(targetRoot, targetPath, "Workspace deletion path");
+    import_node_fs.default.rmSync(targetPath, { recursive: true, force: true });
+  }
+  for (const relativePath of sourceFiles) {
+    const sourcePath = import_node_path.default.resolve(sourceRoot, ...relativePath.split("/"));
+    if (!import_node_fs.default.existsSync(sourcePath)) continue;
+    const stat = import_node_fs.default.lstatSync(sourcePath);
+    if (!stat.isFile() && !stat.isSymbolicLink()) continue;
+    const targetPath = import_node_path.default.resolve(targetRoot, ...relativePath.split("/"));
+    if (entriesEqual(sourcePath, targetPath)) continue;
+    copyEntry(sourceRoot, targetRoot, relativePath);
+  }
+  removeEmptyDirectories(targetRoot);
+}
+function mirrorVisibleProjectToShadow(input, manifest, branchName) {
+  const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(visibleRoot, ".git"))) return;
+  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...workspaceProjectBranchRelativePath(manifest.projectId, branchName).split("/"));
+  mirrorFileSet(visibleRoot, shadowRoot, listGitEligibleFiles(visibleRoot), listFilesRecursively(shadowRoot));
+}
+function mirrorShadowProjectToVisible(input, manifest, branchName) {
+  const visibleRoot = visibleProjectBranchPath(input.projectsRoot, manifest, branchName);
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(visibleRoot, ".git"))) return;
+  const relativeRoot = workspaceProjectBranchRelativePath(manifest.projectId, branchName);
+  const shadowRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
+  const shadowFiles = listShadowTrackedFiles(input, relativeRoot);
+  mirrorFileSet(shadowRoot, visibleRoot, shadowFiles, listGitEligibleFiles(visibleRoot));
+}
+function mirrorLocalPlansToShadow(input, manifest, branchName) {
+  const sourceRoot = localPlansBranchPath(input.plansRoot, manifest.projectId, branchName);
+  if (!import_node_fs.default.existsSync(sourceRoot)) return;
+  const targetRoot = import_node_path.default.join(input.shadowRoot, ...workspacePlansRelativePath(manifest.projectId, branchName).split("/"));
+  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
+  mirrorFileSet(sourceRoot, targetRoot, listFilesRecursively(sourceRoot, planFilter), listFilesRecursively(targetRoot));
+}
+function mirrorShadowPlansToLocal(input, manifest, branchName) {
+  const relativeRoot = workspacePlansRelativePath(manifest.projectId, branchName);
+  const sourceRoot = import_node_path.default.join(input.shadowRoot, ...relativeRoot.split("/"));
+  const targetRoot = localPlansBranchPath(input.plansRoot, manifest.projectId, branchName);
+  const planFilter = (relativePath) => relativePath.endsWith(".plan.md");
+  mirrorFileSet(
+    sourceRoot,
+    targetRoot,
+    listShadowTrackedFiles(input, relativeRoot).filter(planFilter),
+    listFilesRecursively(targetRoot, planFilter)
+  );
+}
+function pruneDirectoryChildren(root, allowedNames) {
+  if (!import_node_fs.default.existsSync(root)) return;
+  for (const entry of import_node_fs.default.readdirSync(root)) {
+    if (allowedNames.has(entry)) continue;
+    const target = import_node_path.default.resolve(root, entry);
+    assertInside(root, target, "Workspace manifest prune path");
+    import_node_fs.default.rmSync(target, { recursive: true, force: true });
+  }
+}
+function pruneShadowToManifest(input) {
+  const projectIds = new Set(input.projects.map((project) => project.projectId));
+  const projectsRoot = import_node_path.default.join(input.shadowRoot, "projects");
+  const plansRoot = import_node_path.default.join(input.shadowRoot, "plans");
+  pruneDirectoryChildren(projectsRoot, projectIds);
+  pruneDirectoryChildren(plansRoot, projectIds);
+  for (const manifest of input.projects) {
+    const encodedBranches = new Set(manifest.branches.map(encodeWorkspaceBranch));
+    pruneDirectoryChildren(import_node_path.default.join(projectsRoot, manifest.projectId, "branches"), encodedBranches);
+    pruneDirectoryChildren(import_node_path.default.join(plansRoot, manifest.projectId), encodedBranches);
+  }
+}
+function mirrorVisibleWorkspaceToShadow(input, excludedCheckouts = /* @__PURE__ */ new Set()) {
+  pruneShadowToManifest(input);
+  for (const manifest of [...input.projects].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
+    for (const branchName of [...new Set(manifest.branches)].sort()) {
+      if (excludedCheckouts.has(`${manifest.projectId}\0${branchName}`)) continue;
+      mirrorVisibleProjectToShadow(input, manifest, branchName);
+      mirrorLocalPlansToShadow(input, manifest, branchName);
+    }
+  }
+}
+function reconcileNewVisibleCheckouts(input) {
+  for (const target of input.newVisibleCheckouts ?? []) {
+    const manifest = input.projects.find((project) => project.projectId === target.projectId);
+    if (!manifest || !manifest.branches.includes(target.branchName)) continue;
+    const projectRoot = workspaceProjectBranchRelativePath(target.projectId, target.branchName);
+    if (listShadowTrackedFiles(input, projectRoot).length > 0) {
+      mirrorShadowProjectToVisible(input, manifest, target.branchName);
+    } else {
+      mirrorVisibleProjectToShadow(input, manifest, target.branchName);
+    }
+    const plansRoot = workspacePlansRelativePath(target.projectId, target.branchName);
+    if (listShadowTrackedFiles(input, plansRoot).length > 0) {
+      mirrorShadowPlansToLocal(input, manifest, target.branchName);
+    } else {
+      mirrorLocalPlansToShadow(input, manifest, target.branchName);
+    }
+  }
+}
+function mirrorShadowWorkspaceToVisible(input) {
+  for (const manifest of [...input.projects].sort((left, right) => left.projectId.localeCompare(right.projectId))) {
+    for (const branchName of [...new Set(manifest.branches)].sort()) {
+      mirrorShadowProjectToVisible(input, manifest, branchName);
+      mirrorShadowPlansToLocal(input, manifest, branchName);
+    }
+  }
+}
+function ensureShadowWorkspace(input) {
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(input.shadowRoot), { recursive: true });
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(input.shadowRoot, ".git"))) {
+    import_node_fs.default.rmSync(input.shadowRoot, { recursive: true, force: true });
+    const clone = runGitResult(input, import_node_path.default.dirname(input.shadowRoot), ["clone", "--origin", "origin", input.remoteUrl, input.shadowRoot]);
+    if (clone.exitCode !== 0) {
+      throw new Error(`clone canonical workspace: ${clone.stderr || clone.stdout || `git exited ${clone.exitCode}`}`);
+    }
+  }
+  if (tryGit(input, input.shadowRoot, ["remote", "get-url", "origin"])) {
+    runGit(input, input.shadowRoot, ["remote", "set-url", "origin", input.remoteUrl], "update canonical workspace remote");
+  } else {
+    runGit(input, input.shadowRoot, ["remote", "add", "origin", input.remoteUrl], "add canonical workspace remote");
+  }
+  runGit(input, input.shadowRoot, ["config", "user.name", "r5d.dev Worker"], "configure workspace Git name");
+  runGit(input, input.shadowRoot, ["config", "user.email", "worker@r5d.dev"], "configure workspace Git email");
+  runGit(input, input.shadowRoot, ["fetch", "origin", "--prune"], "fetch canonical workspace");
+  const hasHead = tryGit(input, input.shadowRoot, ["rev-parse", "--verify", "HEAD"]);
+  const hasRemoteMain = tryGit(input, input.shadowRoot, ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${WORKSPACE_BRANCH}`]);
+  if (!hasHead && hasRemoteMain) {
+    runGit(input, input.shadowRoot, ["checkout", "-B", WORKSPACE_BRANCH, `origin/${WORKSPACE_BRANCH}`], "checkout canonical workspace");
+  } else if (!hasHead) {
+    runGit(input, input.shadowRoot, ["checkout", "--orphan", WORKSPACE_BRANCH], "create canonical workspace branch");
+  }
+}
+function revParse(input, revision) {
+  const result = runGitResult(input, input.shadowRoot, ["rev-parse", "--verify", revision]);
+  return result.exitCode === 0 ? result.stdout : null;
+}
+function gitStatus(input) {
+  return runGit(input, input.shadowRoot, ["status", "--porcelain=v1", "--untracked-files=all"], "read workspace status");
+}
+function stagedPaths(input) {
+  return runGit(input, input.shadowRoot, ["diff", "--cached", "--name-only", "-z"], "list workspace changes").split("\0").filter(Boolean).sort();
+}
+async function stagedDiffSizeBytes(input) {
+  const subprocess = Bun.spawn(gitArgs(input, ["diff", "--cached", "--binary", "--no-ext-diff"]), {
+    cwd: input.shadowRoot,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  const stderrPromise = new Response(subprocess.stderr).text();
+  const reader = subprocess.stdout.getReader();
+  let total = 0;
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    total += chunk.value.byteLength;
+    if (total > MAX_WORKSPACE_SYNC_DIFF_BYTES) {
+      subprocess.kill();
+      await subprocess.exited;
+      await stderrPromise;
+      return MAX_WORKSPACE_SYNC_DIFF_BYTES + 1;
+    }
+  }
+  const exitCode = await subprocess.exited;
+  const stderr = (await stderrPromise).trim();
+  if (exitCode !== 0) throw new Error(`measure workspace diff: ${stderr || `git exited ${exitCode}`}`);
+  return total;
+}
+function reportedPaths(paths) {
+  if (paths.length <= MAX_REPORTED_WORKSPACE_PATHS) return paths;
+  return [
+    ...paths.slice(0, MAX_REPORTED_WORKSPACE_PATHS),
+    `[${paths.length - MAX_REPORTED_WORKSPACE_PATHS} additional paths omitted; inspect with git status]`
+  ];
+}
+function reportedStatus(status) {
+  const bytes = Buffer.from(status, "utf8");
+  if (bytes.length <= MAX_REPORTED_WORKSPACE_STATUS_BYTES) return status;
+  return `${new TextDecoder().decode(bytes.subarray(0, MAX_REPORTED_WORKSPACE_STATUS_BYTES))}
+[status truncated; inspect on the origin worker]`;
+}
+function affectedProjects(paths) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const filePath of paths) {
+    const match = /^(?:projects|plans)\/([^/]+)\//.exec(filePath);
+    if (match?.[1]) ids.add(match[1]);
+  }
+  return [...ids].sort();
+}
+function commitMessage(input) {
+  return JSON.stringify({
+    type: "workspace_sync",
+    attemptId: input.attemptId,
+    worker: input.workerLabel,
+    trigger: input.trigger,
+    ...input.confirmedLargeDiff ? { confirmedLargeDiff: true, confirmationReason: input.confirmationReason } : {}
+  });
+}
+function isNonFastForward(result) {
+  const output = `${result.stdout}
+${result.stderr}`.toLowerCase();
+  return output.includes("non-fast-forward") || output.includes("fetch first") || output.includes("[rejected]");
+}
+function resetShadowToRemote(input) {
+  runGit(input, input.shadowRoot, ["fetch", "origin", "--prune"], "fetch canonical workspace before reset");
+  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+  if (!remoteHead) return null;
+  runGitResult(input, input.shadowRoot, ["rebase", "--abort"]);
+  runGit(input, input.shadowRoot, ["reset", "--hard", `origin/${WORKSPACE_BRANCH}`], "reset workspace to canonical state");
+  runGit(input, input.shadowRoot, ["clean", "-fd"], "clean reset workspace");
+  mirrorShadowWorkspaceToVisible(input);
+  return remoteHead;
+}
+function baseResult(input, startingHead) {
+  return {
+    type: "workspace_sync",
+    attemptId: input.attemptId ?? crypto.randomUUID(),
+    workerLabel: input.workerLabel,
+    trigger: input.trigger,
+    startingHead,
+    rebaseCount: 0,
+    diffSizeBytes: 0,
+    gitStatus: "",
+    affectedProjects: [],
+    affectedPaths: [],
+    discardedPaths: [],
+    localChangesDiscarded: false
+  };
+}
+async function synchronizeWorkspace(rawInput) {
+  const input = { ...rawInput, attemptId: rawInput.attemptId ?? crypto.randomUUID() };
+  try {
+    ensureShadowWorkspace(input);
+    const remoteHeadAtStart = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+    const result = baseResult(input, remoteHeadAtStart);
+    if (input.resetToCanonical) {
+      const publishedHead = resetShadowToRemote(input);
+      return {
+        ...result,
+        outcome: "reset",
+        publishedHead: publishedHead ?? void 0,
+        localChangesDiscarded: true,
+        gitStatus: gitStatus(input)
+      };
+    }
+    if (!input.skipVisibleMirror) {
+      const newCheckoutKeys = new Set((input.newVisibleCheckouts ?? []).map((target) => `${target.projectId}\0${target.branchName}`));
+      mirrorVisibleWorkspaceToShadow(input, newCheckoutKeys);
+      reconcileNewVisibleCheckouts(input);
+    }
+    runGit(input, input.shadowRoot, ["add", "-A"], "stage workspace changes");
+    const paths = stagedPaths(input);
+    const diffSizeBytes = await stagedDiffSizeBytes(input);
+    const statusBeforeCommit = reportedStatus(gitStatus(input));
+    const observed = {
+      ...result,
+      diffSizeBytes,
+      gitStatus: statusBeforeCommit,
+      affectedPaths: reportedPaths(paths),
+      affectedProjects: affectedProjects(paths)
+    };
+    if (paths.length > 0 && diffSizeBytes > MAX_WORKSPACE_SYNC_DIFF_BYTES && !input.confirmedLargeDiff) {
+      return { ...observed, outcome: "large_diff_blocked" };
+    }
+    if (paths.length > 0) {
+      runGit(input, input.shadowRoot, ["commit", "-m", commitMessage(input)], "commit workspace changes");
+    }
+    const candidateHead = revParse(input, "HEAD");
+    const hasRemoteMain = Boolean(revParse(input, `origin/${WORKSPACE_BRANCH}`));
+    const hasUnpushedCommit = candidateHead ? !hasRemoteMain || !tryGit(input, input.shadowRoot, ["merge-base", "--is-ancestor", candidateHead, `origin/${WORKSPACE_BRANCH}`]) : false;
+    if (!hasUnpushedCommit) {
+      const localHead = revParse(input, "HEAD");
+      const currentRemoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+      if (currentRemoteHead && localHead !== currentRemoteHead) {
+        runGit(input, input.shadowRoot, ["reset", "--hard", `origin/${WORKSPACE_BRANCH}`], "update workspace from canonical state");
+        runGit(input, input.shadowRoot, ["clean", "-fd"], "clean updated workspace");
+        mirrorShadowWorkspaceToVisible(input);
+        return {
+          ...observed,
+          outcome: "updated",
+          candidateHead: candidateHead ?? void 0,
+          publishedHead: currentRemoteHead,
+          gitStatus: gitStatus(input)
+        };
+      }
+      if (input.skipVisibleMirror) mirrorShadowWorkspaceToVisible(input);
+      return {
+        ...observed,
+        outcome: "no_change",
+        candidateHead: candidateHead ?? void 0,
+        publishedHead: currentRemoteHead ?? localHead ?? void 0,
+        gitStatus: gitStatus(input)
+      };
+    }
+    let rebaseCount = 0;
+    for (let pushAttempt = 0; pushAttempt < 3; pushAttempt += 1) {
+      const push = runGitResult(input, input.shadowRoot, ["push", "origin", `HEAD:refs/heads/${WORKSPACE_BRANCH}`]);
+      if (push.exitCode === 0) {
+        const publishedHead = revParse(input, "HEAD") ?? candidateHead;
+        mirrorShadowWorkspaceToVisible(input);
+        return {
+          ...observed,
+          outcome: "published",
+          candidateHead: candidateHead ?? void 0,
+          publishedHead: publishedHead ?? void 0,
+          rebaseCount,
+          gitStatus: gitStatus(input)
+        };
+      }
+      if (!isNonFastForward(push)) {
+        return {
+          ...observed,
+          outcome: "failed",
+          candidateHead: candidateHead ?? void 0,
+          rebaseCount,
+          error: push.stderr || push.stdout || "Workspace push failed",
+          gitStatus: gitStatus(input)
+        };
+      }
+      runGit(input, input.shadowRoot, ["fetch", "origin", "--prune"], "fetch workspace after push race");
+      const rebase = runGitResult(input, input.shadowRoot, ["rebase", `origin/${WORKSPACE_BRANCH}`]);
+      rebaseCount += 1;
+      if (rebase.exitCode !== 0) {
+        const conflicted = runGitResult(input, input.shadowRoot, ["diff", "--name-only", "--diff-filter=U", "-z"]);
+        const discardedPaths = reportedPaths([.../* @__PURE__ */ new Set([...paths, ...conflicted.stdout.split("\0").filter(Boolean)])].sort());
+        const publishedHead = resetShadowToRemote(input);
+        return {
+          ...observed,
+          outcome: "conflict_reset",
+          candidateHead: candidateHead ?? void 0,
+          publishedHead: publishedHead ?? void 0,
+          rebaseCount,
+          discardedPaths,
+          localChangesDiscarded: true,
+          gitStatus: gitStatus(input)
+        };
+      }
+    }
+    return {
+      ...observed,
+      outcome: "failed",
+      candidateHead: candidateHead ?? void 0,
+      rebaseCount,
+      error: "Workspace push did not converge after three attempts",
+      gitStatus: gitStatus(input)
+    };
+  } catch (error) {
+    const result = baseResult(input, null);
+    return {
+      ...result,
+      outcome: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function calculateWorkspaceDiffFingerprint(input) {
+  ensureShadowWorkspace(input);
+  if (!input.skipVisibleMirror) mirrorVisibleWorkspaceToShadow(input);
+  runGit(input, input.shadowRoot, ["add", "-A"], "stage workspace fingerprint");
+  const stagedTree = runGit(input, input.shadowRoot, ["write-tree"], "write workspace fingerprint tree");
+  const headTree = revParse(input, "HEAD^{tree}");
+  const localHead = revParse(input, "HEAD");
+  const remoteHead = revParse(input, `origin/${WORKSPACE_BRANCH}`);
+  if (stagedTree === headTree && localHead === remoteHead) {
+    return (0, import_node_crypto.createHash)("sha256").update("").digest("hex");
+  }
+  return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify({ stagedTree, localHead, remoteHead })).digest("hex");
+}
+class WorkspaceSyncSingleFlight {
+  queue = Promise.resolve();
+  run(input) {
+    const queued = this.queue.then(
+      () => synchronizeWorkspace(input),
+      () => synchronizeWorkspace(input)
+    );
+    this.queue = queued.then(
+      () => void 0,
+      () => void 0
+    );
+    return queued;
+  }
+  fingerprint(input) {
+    const queued = this.queue.then(
+      () => calculateWorkspaceDiffFingerprint(input),
+      () => calculateWorkspaceDiffFingerprint(input)
+    );
+    this.queue = queued.then(
+      () => void 0,
+      () => void 0
+    );
+    return queued;
+  }
+  afterCurrent() {
+    return this.queue;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_WORKSPACE_SYNC_DIFF_BYTES,
+  WORKSPACE_BRANCH,
+  WORKSPACE_PERIODIC_SCAN_INTERVAL_MS,
+  WorkspaceSyncSingleFlight,
+  calculateWorkspaceDiffFingerprint,
+  encodeWorkspaceBranch,
+  mirrorShadowWorkspaceToVisible,
+  mirrorVisibleWorkspaceToShadow,
+  synchronizeWorkspace,
+  visibleProjectBranchPath,
+  workspacePlansRelativePath,
+  workspaceProjectBranchRelativePath
+});