@maycombhq/atticus 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/{chunk-WS7KBKP4.js → chunk-X5B7KYPD.js}

@@ -9,16 +9,18 @@ import {
   orgPackDirOf,
   runsDirOf,
   toCanonicalYaml
-} from "./chunk-GLISHJ4G.js";
+} from "./chunk-WJWSB65O.js";
 import {
+  killProcessTree,
+  trackTree,
   withSharedFileLock
-} from "./chunk-G3ZFEHCX.js";
+} from "./chunk-SMFFUFMN.js";
 import {
   ChangeRepos,
   RecordId,
   RepoManifest,
   WORKSPACE_SCHEMA_VERSION
-} from "./chunk-LZFKJ2BR.js";
+} from "./chunk-A3LVMCA5.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";
@@ -40,6 +42,12 @@ var GitError = class extends Error {
     this.name = "GitError";
   }
 };
+var GitStoppedError = class extends GitError {
+  constructor(args) {
+    super(`git ${args[0] ?? ""} stopped`, args, null, "");
+    this.name = "GitStoppedError";
+  }
+};
 function createGit(opts = {}) {
   const env = {
     ...opts.env ?? process.env,
@@ -48,15 +56,30 @@ function createGit(opts = {}) {
     LC_ALL: "C"
   };
   const pre = process.platform === "win32" ? ["-c", "core.longpaths=true"] : [];
-  return (args, cwd) => new Promise((resolve, reject) => {
-    execFile("git", [...pre, ...args], {
+  return (args, cwd, o = {}) => new Promise((resolve, reject) => {
+    const signal = o.signal;
+    if (signal?.aborted) {
+      reject(new GitStoppedError(args));
+      return;
+    }
+    let stopped = false;
+    const child = execFile("git", [...pre, ...args], {
       cwd,
       env,
       timeout: opts.timeoutMs ?? 10 * 6e4,
       maxBuffer: 64 * 1024 * 1024,
       windowsHide: true,
-      encoding: "utf8"
+      encoding: "utf8",
+      // A git that may be stopped runs in its own process group (POSIX), so the stop takes
+      // what it started too. Only then: a terminal's Ctrl+C still reaches a plain git.
+      ...signal && process.platform !== "win32" ? { detached: true } : {}
     }, (err, stdout, stderr) => {
+      signal?.removeEventListener("abort", onAbort);
+      untrack?.();
+      if (stopped) {
+        reject(new GitStoppedError(args));
+        return;
+      }
       if (err) {
         const code = typeof err.code === "number" ? err.code : null;
         const detail = (stderr || err.message).trim().split(/\r?\n/).slice(-3).join(" ");
@@ -65,6 +88,15 @@ function createGit(opts = {}) {
       }
       resolve({ stdout, stderr });
     });
+    const onAbort = () => {
+      stopped = true;
+      killProcessTree(child);
+    };
+    const untrack = signal ? trackTree(child, (s) => {
+      stopped = true;
+      killProcessTree(child, s);
+    }) : void 0;
+    signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
 
@@ -367,15 +399,22 @@ async function removeEditorWorkspaces(root, change) {
 }
 
 // packages/workspace/dist/state.js
-async function checkoutState(dir, git = createGit()) {
-  const commit = (await git(["rev-parse", "HEAD"], dir)).stdout.trim();
+async function checkoutState(dir, git = createGit(), o = {}) {
+  const head = (await git(["show", "-s", "--format=%H%n%cI", "HEAD"], dir)).stdout.trim();
+  const [commit = "", committedAt] = head.split("\n");
   const status = (await git(["status", "--porcelain", "--untracked-files=normal"], dir)).stdout.trim();
-  return { commit, dirty: status !== "" };
+  const ignore = o.ignore ?? [];
+  const changed = status.split("\n").filter(Boolean).map((l) => l.slice(3).replace(/^"|"$/g, "")).flatMap((p) => p.split(" -> ")).filter((p) => !ignore.some((i) => p === i.replace(/\/$/, "") || p.startsWith(i)));
+  return {
+    commit: commit.trim(),
+    dirty: changed.length > 0,
+    ...committedAt?.trim() ? { committedAt: committedAt.trim() } : {}
+  };
 }
 
 // packages/workspace/dist/manager.js
-import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir3, readdir as readdir3, rm as rm2 } from "node:fs/promises";
+import { constants as fsConstants, existsSync as existsSync2, statSync } from "node:fs";
+import { copyFile, lstat, mkdir as mkdir3, readdir as readdir3, readFile as readFile3, readlink, realpath, rm as rm2, rmdir, symlink, unlink, writeFile as writeFile4 } from "node:fs/promises";
 import { basename, dirname as dirname2, join as join4 } from "node:path";
 var BASE_CLONE_WAIT_MS = 30 * 6e4;
 function withBaseCloneLock(dest, id2, work, waitMs = BASE_CLONE_WAIT_MS) {
@@ -413,8 +452,79 @@ async function remoteDefaultBranch(dir, git = createGit()) {
     return void 0;
   }
 }
+var SYNC_CHECKOUT_MARK = "atticus-sync-checkout.json";
+var TAKES_INDEX_LOCK = /* @__PURE__ */ new Set(["checkout", "status", "sparse-checkout", "read-tree", "reset"]);
+var SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+var PUT_BACK_DIR = "atticus-put-back";
+function linkTextIsBlob(text, mode, blob, platform = process.platform) {
+  if (mode !== "120000")
+    return false;
+  if (platform !== "win32")
+    return text === blob;
+  const slashed = (s) => s.replaceAll("\\", "/");
+  return slashed(text) === slashed(blob);
+}
+function sayKept(kept) {
+  const said = kept.slice(0, 5).map((k2) => `your version of ${k2.path} was kept at ${k2.copy}`).join("; ");
+  const k = kept[0];
+  const folder = k.copy.slice(0, k.copy.length - k.path.length - 1);
+  return kept.length > 5 ? `${said}; and ${kept.length - 5} more, kept under ${folder}` : said;
+}
+function inGroups(paths, max = 8e3) {
+  const out = [];
+  let cur = [];
+  let len = 0;
+  for (const p of paths) {
+    if (cur.length > 0 && len + p.length + 1 > max) {
+      out.push(cur);
+      cur = [];
+      len = 0;
+    }
+    cur.push(p);
+    len += p.length + 1;
+  }
+  if (cur.length > 0)
+    out.push(cur);
+  return out;
+}
+async function throughLink(dest, dir) {
+  if (dir === "." || dir === "")
+    return false;
+  let at = dest;
+  for (const part of dir.split("/")) {
+    at = join4(at, part);
+    const st = await lstat(at).catch(() => void 0);
+    if (!st)
+      return false;
+    if (st.isSymbolicLink())
+      return true;
+  }
+  return false;
+}
+function statusEntries(z) {
+  return z.split("\0").filter((e) => e.length > 3).map((e) => [e.slice(0, 2), e.slice(3)]);
+}
+function sayPaths(entries) {
+  const said = entries.slice(0, 5).map(([xy, p]) => `${p} (${xy === "??" ? "not tracked" : "changed"})`).join(", ");
+  return entries.length > 5 ? `${said} and ${entries.length - 5} more` : said;
+}
 function createWorkspace(root, git = createGit(), opts = {}) {
-  const g = (args, cwd = root) => git(args, cwd);
+  const signal = opts.signal;
+  let busy;
+  let running;
+  let lockAtStop;
+  signal?.addEventListener("abort", () => {
+    if (busy && running && TAKES_INDEX_LOCK.has(running))
+      lockAtStop = lockOf(busy);
+  }, { once: true });
+  const g = async (args, cwd = root) => {
+    running = args[0];
+    try {
+      return await (signal ? git(args, cwd, { signal }) : git(args, cwd));
+    } finally {
+      running = void 0;
+    }
+  };
   const withBaseClone = (dest, id2, work) => withBaseCloneLock(dest, id2, work, opts.lockWaitMs);
   const head = async (cwd) => (await g(["rev-parse", "HEAD"], cwd)).stdout.trim();
   const dirty = async (cwd) => (await g(["status", "--porcelain", "--untracked-files=normal"], cwd)).stdout.trim() !== "";
@@ -471,6 +581,344 @@ function createWorkspace(root, git = createGit(), opts = {}) {
     await g(["checkout", "--quiet", "-B", branch, at], dest);
     return { id: repo.id, action: "cloned", sha: await head(dest), from };
   }
+  const markOf = (dest) => join4(dest, ".git", SYNC_CHECKOUT_MARK);
+  function lockOf(dest) {
+    try {
+      const st = statSync(join4(dest, ".git", "index.lock"), { throwIfNoEntry: false });
+      return st ? `${st.dev}:${st.ino}:${st.mtimeMs}` : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async function dropKilledLock(dest, atStop) {
+    const now = lockOf(dest);
+    if (!now)
+      return true;
+    if (now !== atStop)
+      return false;
+    await rm2(join4(dest, ".git", "index.lock"), { force: true });
+    return true;
+  }
+  async function restoreBaseClone(repo, dest, atStop) {
+    const kept = [];
+    const no = (why) => ({ why, kept });
+    const mark = markOf(dest);
+    const keep = (what) => no(`${what}. Nothing was changed. To keep it, move it out of ${dest} (base clones are read-only) and sync again; or delete ${mark} to keep the clone as it is`);
+    const notOurs = (detail) => no(`its mark ${mark} isn't one a sync writes (${detail}). Nothing was changed. If nothing in ${dest} is yours, put it back with git -C ${dest} checkout --force ${repo.defaultBranch} and git -C ${dest} clean -fd, then delete the mark; or delete the mark to keep the clone as it is`);
+    let was;
+    try {
+      was = JSON.parse(await readFile3(mark, "utf8"));
+    } catch {
+      return notOurs("it can't be read");
+    }
+    if (typeof was !== "object" || was === null)
+      return notOurs("it can't be read");
+    const head2 = typeof was.head === "string" && SHA.test(was.head) ? was.head : "";
+    const target = typeof was.target === "string" && SHA.test(was.target) ? was.target : "";
+    if (!head2 || !target)
+      return notOurs("it names no commit it was on and none it fetched");
+    const branch = typeof was.branch === "string" ? was.branch : "";
+    if (branch !== repo.defaultBranch || branch.startsWith("-") || branch.startsWith("refs/"))
+      return notOurs(`its branch isn't ${repo.defaultBranch}, the manifest's`);
+    const ref = `refs/heads/${branch}`;
+    const read = async (args) => {
+      try {
+        return (await git(args, dest)).stdout.trim();
+      } catch {
+        return "";
+      }
+    };
+    const ok = (args) => git(args, dest).then(() => true, () => false);
+    try {
+      if ((await lstat(dest)).isSymbolicLink())
+        return keep(`${dest} is a link (to ${await realpath(dest).catch(() => "a folder that isn't there")}), not a base clone Atticus made`);
+      const noClone = no(`${dest} is no git clone of its own (its .git folder is broken). Nothing was changed. If nothing in it is yours, delete the folder ${dest} and sync again to clone it afresh; or delete ${mark} to keep it as it is`);
+      if (!(await lstat(join4(dest, ".git"))).isDirectory())
+        return noClone;
+      const top = await read(["rev-parse", "--show-toplevel"]);
+      if (!top || await realpath(top) !== await realpath(dest))
+        return noClone;
+      if (!await ok(["check-ref-format", ref]))
+        return notOurs(`${branch} is no branch name`);
+      if (await read(["symbolic-ref", "--quiet", "HEAD"]) !== ref)
+        return keep(`the base clone isn't on ${branch} as the sync left it`);
+      const origin = `refs/remotes/origin/${branch}`;
+      if (await read(["rev-parse", "--verify", "--quiet", origin]) !== target && !(await read(["rev-parse", "--verify", "--quiet", `${target}^{commit}`]) === target && (await ok(["merge-base", "--is-ancestor", target, origin]) || (await read(["reflog", "show", "--format=%H", origin, "--"])).split("\n").includes(target))))
+        return notOurs(`the commit it names as fetched was never origin/${branch}`);
+      const tip = await read(["rev-parse", "--verify", "--quiet", ref]);
+      if (tip !== head2 && tip !== target)
+        return keep(`${branch} is at ${tip.slice(0, 12) || "no commit"}, a commit that sync didn't leave`);
+      if (tip === target && target !== head2) {
+        const before = await read(["rev-parse", "--verify", "--quiet", `${ref}@{1}`]);
+        if (before !== head2 && !await ok(["reflog", "exists", ref]))
+          return no(`${branch} is at ${tip.slice(0, 12)}, the commit that sync fetched, but this clone's history can't show the sync left it (git keeps no reflog of ${branch} there). Nothing was changed. To let Atticus put it back, set ${branch} back to the commit it was on with git -C ${dest} update-ref ${ref} ${head2} ${target} and sync again; or delete ${mark} to keep the clone as it is`);
+        if (before !== head2)
+          return keep(`${branch} is at ${tip.slice(0, 12)} but wasn't moved there from ${head2.slice(0, 12)} by that sync`);
+      }
+      if (!await read(["rev-parse", "--verify", "--quiet", `${head2}^{commit}`]))
+        return notOurs(`it names a commit the clone hasn't got`);
+      const differ = (await git(["diff-tree", "-r", "-z", "--no-renames", "--no-commit-id", head2, target], dest)).stdout.split("\0");
+      const added = /* @__PURE__ */ new Set();
+      const inBoth = /* @__PURE__ */ new Set();
+      const blobs = /* @__PURE__ */ new Map();
+      const entries = /* @__PURE__ */ new Map();
+      const ignoreCase = await read(["config", "--bool", "core.ignorecase"]) === "true";
+      const keyOf = (p) => ignoreCase ? p.toLowerCase() : p;
+      const NONE = /^0+$/;
+      const swapped = [];
+      for (let i = 0; i + 1 < differ.length; i += 2) {
+        const [from, to, was2, now2, st] = differ[i].split(" ");
+        const p = differ[i + 1];
+        (st === "A" ? added : inBoth).add(p);
+        const modes = [from.slice(1), to];
+        if (modes.includes("160000") && !modes.includes("000000") && modes[0] !== modes[1])
+          swapped.push(p);
+        const known = blobs.get(keyOf(p)) ?? /* @__PURE__ */ new Set();
+        for (const b of [was2, now2])
+          if (b && !NONE.test(b))
+            known.add(b);
+        blobs.set(keyOf(p), known);
+        const both = entries.get(keyOf(p)) ?? [];
+        [was2, now2].forEach((b, k) => {
+          if (b && !NONE.test(b))
+            both.push([modes[k], b]);
+        });
+        entries.set(keyOf(p), both);
+      }
+      const inDiff = (p) => added.has(p) || inBoth.has(p);
+      const ownLinks = [];
+      for (const p of swapped) {
+        if (await throughLink(dest, dirname2(p)))
+          return keep(`a folder on the way to ${p} is a link, where one commit has a submodule and the other a file`);
+        const st = await lstat(join4(dest, p)).catch(() => void 0);
+        if (st?.isSymbolicLink()) {
+          const to = await readlink(join4(dest, p));
+          if (!await gitsOwnLink(dest, to, entries.get(keyOf(p)) ?? []))
+            return keep(`${p} is a link, where one commit has a submodule and the other a file`);
+          ownLinks.push(p);
+        } else if (st?.isDirectory() && (await readdir3(join4(dest, p))).length > 0)
+          return keep(`${p} is a folder with files in it, where one commit has a submodule and the other a file`);
+      }
+      const status = async (skip = []) => statusEntries((await git([
+        "status",
+        "--porcelain=v1",
+        "-z",
+        "--no-renames",
+        "--untracked-files=all",
+        "--ignore-submodules=none",
+        // each path as written, from the clone's top (a link of git's own, put back below)
+        ...skip.length ? ["--", ...skip.map((p) => `:(top,exclude,literal)${p}`)] : []
+      ], dest)).stdout);
+      const theirs = (await status(ownLinks)).filter(([, p]) => !inDiff(p));
+      if (theirs.length > 0)
+        return keep(`what that checkout didn't write is changed: ${sayPaths(theirs)}`);
+      const staged = /* @__PURE__ */ new Set();
+      const indexed = [];
+      for (const e of (await git(["ls-files", "--stage", "-z"], dest)).stdout.split("\0")) {
+        const tab = e.indexOf("	");
+        if (tab >= 0)
+          indexed.push(e.slice(tab + 1));
+        if (tab < 0 || !inDiff(e.slice(tab + 1)))
+          continue;
+        const [, blob, stage] = e.slice(0, tab).split(" ");
+        if (stage !== "0" || !blobs.get(keyOf(e.slice(tab + 1)))?.has(blob))
+          staged.add(e.slice(tab + 1));
+      }
+      if (staged.size > 0)
+        return no(`what that checkout didn't write is staged: ${sayPaths([...staged].map((p) => ["A ", p]))}. Nothing was changed. To keep it, move it out of ${dest} (base clones are read-only) and unstage it there (git -C ${dest} restore --staged -- <path>), then sync again; or delete ${mark} to keep the clone as it is`);
+      if (!await dropKilledLock(dest, atStop))
+        return no(`git's lock ${join4(dest, ".git", "index.lock")} is there: if no git is running in ${dest}, delete it; the next sync puts the clone back (its mark ${mark} stays until then)`);
+      if (tip !== head2)
+        await git(["update-ref", "-m", "atticus: a stopped sync put back", ref, head2, tip], dest);
+      for (const p of ownLinks)
+        if ((await lstat(join4(dest, p)).catch(() => void 0))?.isSymbolicLink())
+          await unlink(join4(dest, p));
+      const now = (await status()).map(([, p]) => p);
+      const strays = ignoreCase ? await hiddenByCase(dest, [...added], now, indexed) : [];
+      kept.push(...await keepTheirs(dest, [...now, ...strays], (p) => blobs.get(keyOf(p)) ?? /* @__PURE__ */ new Set(), (p) => entries.get(keyOf(p)) ?? [], new Set(indexed)));
+      const back = now.filter((p) => inBoth.has(p));
+      const out = now.filter((p) => added.has(p));
+      for (const ps of inGroups(out))
+        await git(["update-index", "--force-remove", "--", ...ps], dest);
+      const lit = (ps) => ps.map((p) => `:(literal)${p}`);
+      const files = [];
+      for (const p of out) {
+        const st = await lstat(join4(dest, p)).catch(() => void 0);
+        if (st && !st.isDirectory() && !await throughLink(dest, dirname2(p)))
+          files.push(p);
+      }
+      for (const ps of inGroups(files))
+        await git(["clean", "-fq", "--", ...lit(ps)], dest);
+      for (const p of strays)
+        await rm2(join4(dest, p), { force: true });
+      const headFolders = /* @__PURE__ */ new Set();
+      for (const e of (await git(["ls-tree", "-r", "-t", "-z", head2], dest)).stdout.split("\0")) {
+        const [, type] = e.slice(0, Math.max(0, e.indexOf("	"))).split(" ");
+        if (type === "tree" || type === "commit")
+          headFolders.add(keyOf(e.slice(e.indexOf("	") + 1)));
+      }
+      for (const p of added)
+        for (let d = dirname2(p); d !== "." && d !== "" && d !== "/"; d = dirname2(d))
+          if (headFolders.has(keyOf(d)) || await throughLink(dest, d) || !await rmdir(join4(dest, d)).then(() => true, () => false))
+            break;
+      for (const ps of inGroups(back))
+        await git(["checkout", "--quiet", head2, "--", ...lit(ps)], dest);
+      const left = await status();
+      if (left.length > 0)
+        return no(`putting it back left ${sayPaths(left)}; its mark ${mark} stays, so the next sync tries again${kept.length ? `; ${sayKept(kept)}` : ""}`);
+      await rm2(mark, { force: true });
+      return { kept };
+    } catch (e) {
+      return no(`${e.message}; its mark ${mark} stays, so the next sync tries again${kept.length ? `; ${sayKept(kept)}` : ""}`);
+    }
+  }
+  async function hiddenByCase(dest, added, listed, indexed) {
+    const seen = new Set(listed);
+    const exact = new Set(indexed);
+    const byCase = /* @__PURE__ */ new Map();
+    for (const q of indexed)
+      byCase.set(q.toLowerCase(), [...byCase.get(q.toLowerCase()) ?? [], q]);
+    const out = [];
+    for (const p of added) {
+      if (seen.has(p) || exact.has(p))
+        continue;
+      const others = byCase.get(p.toLowerCase()) ?? [];
+      if (others.length === 0)
+        continue;
+      const st = await lstat(join4(dest, p)).catch(() => void 0);
+      if (!st || st.isDirectory())
+        continue;
+      let same = false;
+      for (const q of others) {
+        const o = await lstat(join4(dest, q)).catch(() => void 0);
+        if (o && o.dev === st.dev && o.ino === st.ino)
+          same = true;
+      }
+      if (!same && !await throughLink(dest, dirname2(p)))
+        out.push(p);
+    }
+    return out;
+  }
+  async function gitsOwnLink(dest, to, entries) {
+    for (const [mode, b] of entries) {
+      if (mode !== "120000")
+        continue;
+      const text = (await git(["cat-file", "blob", b], dest).catch(() => void 0))?.stdout;
+      if (text !== void 0 && linkTextIsBlob(to, mode, text))
+        return true;
+    }
+    return false;
+  }
+  async function keepTheirs(dest, paths, known, entries, indexed) {
+    const files = [];
+    const links = [];
+    const seen = /* @__PURE__ */ new Map();
+    const first = [...new Set(paths)].sort((a, b) => +indexed.has(b) - +indexed.has(a));
+    for (const p of first) {
+      if (await throughLink(dest, dirname2(p)))
+        continue;
+      const st = await lstat(join4(dest, p), { bigint: true }).catch(() => void 0);
+      if (!st)
+        continue;
+      const id2 = `${st.dev}:${st.ino}`;
+      const was = seen.get(id2);
+      if (st.ino !== 0n && was !== void 0 && was.toLowerCase() === p.toLowerCase())
+        continue;
+      if (was === void 0)
+        seen.set(id2, p);
+      if (st.isFile())
+        files.push(p);
+      else if (st.isSymbolicLink())
+        links.push(p);
+    }
+    const theirs = [];
+    for (const ps of inGroups(files)) {
+      const ids = (await git(["hash-object", "--", ...ps], dest)).stdout.trim().split("\n");
+      ps.forEach((p, i) => {
+        if (!known(p).has(ids[i].trim()))
+          theirs.push(p);
+      });
+    }
+    const linkText = /* @__PURE__ */ new Map();
+    for (const p of links) {
+      const to = await readlink(join4(dest, p));
+      linkText.set(p, to);
+      if (!await gitsOwnLink(dest, to, entries(p)))
+        theirs.push(p);
+    }
+    if (theirs.length === 0)
+      return [];
+    const top = join4(dest, ".git", PUT_BACK_DIR);
+    await mkdir3(top, { recursive: true });
+    if (!(await lstat(top)).isDirectory())
+      throw new Error(`${top} isn't a folder of its own (a link?): nothing was copied there`);
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    let at = join4(top, stamp);
+    for (let n = 2; ; n++) {
+      try {
+        await mkdir3(at);
+        break;
+      } catch (e) {
+        if (e.code !== "EEXIST" || n > 100)
+          throw e;
+        at = join4(top, `${stamp}-${n}`);
+      }
+    }
+    const out = [];
+    for (const p of theirs) {
+      const copy = join4(at, ...p.split("/"));
+      await mkdir3(dirname2(copy), { recursive: true });
+      const to = linkText.get(p);
+      try {
+        if (to === void 0)
+          await copyFile(join4(dest, p), copy, fsConstants.COPYFILE_EXCL);
+        else
+          await symlink(to, copy).catch(() => writeFile4(copy, to, { flag: "wx" }));
+      } catch (e) {
+        if (e.code !== "EEXIST")
+          throw e;
+        const c = await lstat(copy);
+        const there = c.isSymbolicLink() ? await readlink(copy) === to : c.isFile() && (await readFile3(copy)).equals(to === void 0 ? await readFile3(join4(dest, p)) : Buffer.from(to));
+        if (!there)
+          throw e;
+        continue;
+      }
+      out.push({ path: p, copy });
+    }
+    return out;
+  }
+  async function stoppedOne(repo, dest, made, updatedTo) {
+    if (made) {
+      const gone = await rm2(dest, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }).then(() => true).catch(() => false);
+      return {
+        id: repo.id,
+        action: "stopped",
+        reason: gone ? "stopped: the clone it had started was taken away; sync again to clone it" : `stopped: the clone it had started couldn't be taken away; delete ${dest} before you sync again`
+      };
+    }
+    if (updatedTo !== void 0)
+      return {
+        id: repo.id,
+        action: "stopped",
+        sha: updatedTo,
+        reason: `stopped once the base clone was updated, to ${repo.defaultBranch} at ${updatedTo.slice(0, 12)}; sync again to finish`
+      };
+    if (existsSync2(markOf(dest))) {
+      const { why, kept } = await restoreBaseClone(repo, dest, lockAtStop);
+      return {
+        id: repo.id,
+        action: "stopped",
+        ...kept.length ? { kept } : {},
+        reason: why ? `stopped in the base clone's checkout, and it wasn't put back as it was: ${why}` : `stopped: the base clone is back as it was before this sync${kept.length ? `; ${sayKept(kept)}` : ""}; sync again`
+      };
+    }
+    await dropKilledLock(dest, lockAtStop).catch(() => false);
+    return {
+      id: repo.id,
+      action: "stopped",
+      reason: "stopped: the base clone is as it was before this sync; sync again"
+    };
+  }
   async function syncOne(repo, local) {
     if (repo.archived)
       return { id: repo.id, action: "skipped", reason: "archived" };
@@ -483,6 +931,14 @@ function createWorkspace(root, git = createGit(), opts = {}) {
     const dest = baseClonePath(root, repo.id);
     const branch = repo.defaultBranch;
     const made = !existsSync2(dest);
+    busy = made ? void 0 : dest;
+    let earlier = [];
+    let updatedTo;
+    const said = (r) => earlier.length === 0 ? r : {
+      ...r,
+      kept: [...earlier, ...r.kept ?? []],
+      reason: `${r.reason ? `${r.reason}; ` : ""}an earlier sync's stopped checkout was put back first: ${sayKept(earlier)}`
+    };
     try {
       if (made) {
         await mkdir3(dirname2(dest), { recursive: true });
@@ -511,33 +967,56 @@ function createWorkspace(root, git = createGit(), opts = {}) {
           ...await remoteDefault(dest)
         };
       }
+      if (existsSync2(markOf(dest))) {
+        const { why, kept } = await restoreBaseClone(repo, dest);
+        if (why)
+          return {
+            id: repo.id,
+            action: "failed",
+            ...kept.length ? { kept } : {},
+            reason: `an earlier sync was stopped in the base clone's checkout, and it wasn't put back: ${why}`
+          };
+        earlier = kept;
+      }
       if (await dirty(dest)) {
-        return {
+        return said({
           id: repo.id,
           action: "skipped",
           sha: await head(dest),
           reason: "the base clone has local changes; base clones are read-only"
-        };
+        });
       }
+      const before = await head(dest);
       await g(["fetch", "--no-tags", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`], dest);
+      const target = (await g(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${branch}^{commit}`], dest)).stdout.trim();
+      await writeFile4(markOf(dest), `${JSON.stringify({ head: before, target, branch, at: (/* @__PURE__ */ new Date()).toISOString() })}
+`, "utf8");
       await g(["checkout", "--quiet", "-B", branch, `refs/remotes/origin/${branch}`], dest);
       if (repo.sparse.length > 0)
         await g(["sparse-checkout", "set", "--", ...repo.sparse], dest);
-      return {
+      await rm2(markOf(dest), { force: true });
+      updatedTo = target;
+      return said({
         id: repo.id,
         action: "updated",
         sha: await head(dest),
         ...await remoteDefault(dest)
-      };
+      });
     } catch (err) {
+      if (signal?.aborted || err instanceof GitStoppedError)
+        return said(await stoppedOne(repo, dest, made, updatedTo));
       if (made)
         await rm2(dest, { recursive: true, force: true }).catch(() => void 0);
       const msg = err.message;
-      return {
+      const marked = !made && existsSync2(markOf(dest)) ? `; the base clone's checkout mark ${markOf(dest)} stays, so the next sync puts the clone back first` : "";
+      return said({
         id: repo.id,
         action: "failed",
-        reason: /Filename too long/i.test(msg) ? `${msg.trim()} \u2014 a path in the repo is longer than Windows allows: run git config --global core.longpaths true, then sync again` : msg
-      };
+        reason: /Filename too long/i.test(msg) ? `${msg.trim()} \u2014 a path in the repo is longer than Windows allows: run git config --global core.longpaths true, then sync again${marked}` : `${msg}${marked}`
+      });
+    } finally {
+      busy = void 0;
+      lockAtStop = void 0;
     }
   }
   async function worktreeFor(change, repo) {
@@ -602,11 +1081,16 @@ function createWorkspace(root, git = createGit(), opts = {}) {
         await ensureGitignore(root);
       const out = [];
       const local = opts2.from ? await localClones(opts2.from, git) : void 0;
-      for (const repo of repos)
+      for (const repo of repos) {
+        if (signal?.aborted) {
+          out.push({ id: repo.id, action: "stopped", reason: "not started: the sync was stopped" });
+          continue;
+        }
         out.push(
           // Nothing to lock (nor a folder to make) for an archived or in-place repo.
           repo.archived || isInPlace(repo.url) ? await syncOne(repo, local) : await withBaseClone(baseClonePath(root, repo.id), repo.id, () => syncOne(repo, local))
         );
+      }
       return out;
     },
     checkoutBranch(repo, branch) {
@@ -805,6 +1289,7 @@ function nearRepos(entry, listed) {
 
 export {
   GitError,
+  GitStoppedError,
   createGit,
   changedFiles,
   changesSince,
@@ -837,6 +1322,8 @@ export {
   inPlacePath,
   inPlaceDir,
   remoteDefaultBranch,
+  SYNC_CHECKOUT_MARK,
+  PUT_BACK_DIR,
   createWorkspace,
   toHandle,
   gitUser,

package/dist/{chunk-O6DJMDBR.js → chunk-X73WLHSN.js}

@@ -18,14 +18,14 @@ import {
   proposedSince,
   sha256,
   startDecideRun
-} from "./chunk-3WO7ASU7.js";
-import "./chunk-QQD25YNF.js";
-import "./chunk-QA4O2GGC.js";
-import "./chunk-GLISHJ4G.js";
-import "./chunk-G3ZFEHCX.js";
-import "./chunk-LZFKJ2BR.js";
-import "./chunk-CTJHEG6A.js";
+} from "./chunk-AMZ4XMES.js";
+import "./chunk-2MRYL45Z.js";
+import "./chunk-WJWSB65O.js";
+import "./chunk-SMFFUFMN.js";
+import "./chunk-A3LVMCA5.js";
+import "./chunk-NWMFVPEP.js";
 import "./chunk-BQGDB6ZL.js";
+import "./chunk-R4TUWD4C.js";
 import "./chunk-TV45EUGM.js";
 export {
   DECIDE_AGENTS,