jj-octo 0.6.0 → 0.7.0

package/dist/jj-octo.js

@@ -18239,7 +18239,7 @@ var layer14 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch)
 // package.json
 var package_default = {
   name: "jj-octo",
-  version: "0.6.0",
+  version: "0.7.0",
   description: "A jj subcommand for GitHub that supports stacked pull requests and works in Claude Code cloud sessions",
   license: "MIT",
   repository: {
@@ -18439,6 +18439,7 @@ var SCRATCH = '(working_copies() & empty() & description(exact:""))';
 var stackRevset = (revision) => `(reachable(${revision}, mutable()) & (${STACK_ROOTS})::) ~ ${SCRATCH}`;
 var downstackRevset = (revision) => `::(${revision}) & (${stackRevset(revision)})`;
 var upstackRevset = (revision) => `(${revision})+:: & (${stackRevset(revision)})`;
+var anyOf = (revsets) => ["none()", ...revsets].join(" | ");
 var bookmarkRevset = (bookmark) => `bookmarks(exact:"${bookmark}")`;
 var lines2 = (output) => output.split(`
 `).filter((line) => line !== "");
@@ -18544,6 +18545,121 @@ var chain = (revset, revision) => gen2(function* () {
 var stackChanges = (revision) => chain(stackRevset(revision), revision);
 var downstackChanges = (revision) => chain(downstackRevset(revision), revision);
 
+// src/clients/github/openapi.ts
+var responseOf = () => (schema) => schema;
+var bodyOf = (body) => bodyJsonUnsafe(body);
+
+// src/clients/github/types.ts
+var PullRequestNumberSchema = Number6.pipe(brand("PullRequestNumber"));
+var StackNumberSchema = Number6.pipe(brand("StackNumber"));
+
+// src/clients/github/client.ts
+class GitHubFailed extends TaggedError2("GitHubFailed") {
+}
+
+class GitHub extends Service()("jj-octo/GitHub") {
+}
+var CreatedPullRequest = responseOf()(Struct({ number: PullRequestNumberSchema }));
+var CreatedStack = responseOf()(Struct({ number: StackNumberSchema }));
+var PullRequests = responseOf()(ArraySchema(Struct({
+  base: Struct({ ref: String4 }),
+  body: NullOr(String4),
+  draft: optionalKey2(Boolean3),
+  number: PullRequestNumberSchema,
+  title: String4
+})));
+var ClosedPullRequests = responseOf()(ArraySchema(Struct({
+  head: Struct({ sha: String4 }),
+  merged_at: NullOr(String4)
+})));
+var StackedPullRequest = Struct({
+  number: PullRequestNumberSchema,
+  state: Literals(["closed", "open"])
+});
+var Stacks = responseOf()(ArraySchema(Struct({ number: StackNumberSchema, pull_requests: ArraySchema(StackedPullRequest) })));
+var RepositoryDetails = responseOf()(Struct({ default_branch: String4 }));
+var MergeRequest = Struct({
+  details: Struct({
+    message: String4,
+    uuid: optionalKey2(String4)
+  }),
+  status: Literals(["enqueued", "failed", "merged", "pending"])
+});
+var StartedMerge = responseOf()(MergeRequest);
+var MergeResult = responseOf()(MergeRequest);
+var GitHubLive = (repository, connection) => {
+  const repo = (path) => `/repos/${repository.owner}/${repository.name}${path}`;
+  return effect(GitHub, gen2(function* () {
+    const requestInit = match(connection.proxy, {
+      onNone: () => ({}),
+      onSome: ({ ca, url }) => match(ca, {
+        onNone: () => ({ proxy: url }),
+        onSome: (certificates) => ({ proxy: url, tls: { ca: certificates } })
+      })
+    });
+    const client = (yield* HttpClient).pipe(mapRequest((request) => request.pipe(prependUrl("https://api.github.com"), acceptJson, bearerToken(connection.token), setHeaders({
+      "user-agent": "jj-octo",
+      "x-github-api-version": "2022-11-28"
+    }))));
+    const send = (request) => client.execute(request).pipe(provideService2(RequestInit, requestInit), flatMap4((response) => response.status < 400 ? succeed6(response) : response.text.pipe(orElseSucceed2(() => ""), flatMap4((text) => fail6(new GitHubFailed({
+      message: `${request.method} ${request.url} returned ${response.status}: ${text}`
+    }))))), catchTag2("HttpClientError", (error) => fail6(new GitHubFailed({ message: error.message }))));
+    const json = (schema) => (request) => send(request).pipe(flatMap4(schemaBodyJson(schema)), catchTags2({
+      HttpClientError: (error) => fail6(new GitHubFailed({ message: error.message })),
+      SchemaError: (error) => fail6(new GitHubFailed({
+        message: `unexpected response to ${request.url}: ${error.message}`
+      }))
+    }));
+    const stackOf = (pullRequest) => json(Stacks)(get4(repo(`/stacks?pull_request=${pullRequest}`))).pipe(map7((stacks) => map(fromNullishOr(stacks[0]), (stack) => ({
+      number: stack.number,
+      open: stack.pull_requests.filter(({ state }) => state === "open").map(({ number }) => number)
+    }))));
+    const mergeRequest = (path) => json(MergeResult)(get4(repo(path)));
+    const fromBranch = (branch, state) => repo(`/pulls?state=${state}&head=${repository.owner}:${encodeURIComponent(branch)}`);
+    return {
+      addToStack: (stack, pullRequests) => send(post(repo(`/stacks/${stack}/add`)).pipe(bodyOf({ pull_requests: [...pullRequests] }))).pipe(asVoid2),
+      createPullRequest: ({ base, body, draft, head, title }) => json(CreatedPullRequest)(post(repo("/pulls")).pipe(bodyOf({ base, body, draft, head, title }))).pipe(map7(({ number }) => number)),
+      createStack: (pullRequests) => json(CreatedStack)(post(repo("/stacks")).pipe(bodyOf({ pull_requests: [...pullRequests] }))).pipe(map7(({ number }) => number)),
+      defaultBranch: json(RepositoryDetails)(get4(repo(""))).pipe(map7(({ default_branch }) => default_branch)),
+      mergePullRequest: (pullRequest) => send(put(repo(`/pulls/${pullRequest}/merge`)).pipe(bodyOf({ merge_method: "squash" }))).pipe(asVoid2),
+      mergeStack: (pullRequest) => gen2(function* () {
+        const started = yield* json(StartedMerge)(put(repo(`/pulls/${pullRequest}/merge-async`)).pipe(bodyOf({
+          merge_action: "default",
+          merge_method: "squash"
+        })));
+        const { uuid } = started.details;
+        if (uuid === undefined) {
+          return yield* new GitHubFailed({
+            message: `merging #${pullRequest} returned no request to follow`
+          });
+        }
+        const settled = yield* mergeRequest(`/pulls/${pullRequest}/merge-async/${uuid}`).pipe(repeat2({
+          schedule: spaced("5 seconds"),
+          until: ({ status }) => status !== "pending"
+        }));
+        if (settled.status === "merged" || settled.status === "enqueued") {
+          return settled.status;
+        }
+        return yield* new GitHubFailed({
+          message: `merging #${pullRequest} ended ${settled.status}: ${settled.details.message}`
+        });
+      }),
+      mergedHeads: (branch) => json(ClosedPullRequests)(get4(fromBranch(branch, "closed"))).pipe(map7((closed) => closed.filter(({ merged_at }) => merged_at !== null).map(({ head }) => head.sha))),
+      openPullRequest: (branch) => json(PullRequests)(get4(fromBranch(branch, "open"))).pipe(map7((found) => map(fromNullishOr(found[0]), ({ base, body, draft, number, title }) => ({
+        base: base.ref,
+        body: body ?? "",
+        draft: draft ?? false,
+        number,
+        title
+      })))),
+      setBase: (pullRequest, base) => send(patch(repo(`/pulls/${pullRequest}`)).pipe(bodyOf({ base }))).pipe(asVoid2),
+      setDescription: (pullRequest, { body, title }) => send(patch(repo(`/pulls/${pullRequest}`)).pipe(bodyOf({ body, title }))).pipe(asVoid2),
+      stackOf,
+      unstack: (stack) => send(post(repo(`/stacks/${stack}/unstack`))).pipe(asVoid2)
+    };
+  }));
+};
+
 // src/cli/gh/stack/trunk.ts
 class TrunkMismatch extends TaggedError2("TrunkMismatch") {
 }
@@ -18555,6 +18671,11 @@ var checkTrunk = (branch) => gen2(function* () {
     });
   }
 });
+var checkedTrunk = gen2(function* () {
+  const branch = yield* (yield* GitHub).defaultBranch;
+  yield* checkTrunk(branch);
+  return branch;
+});
 
 // src/cli/gh/setup.ts
 class NotSetUp extends TaggedError2("NotSetUp") {
@@ -18688,121 +18809,6 @@ var init = gen2(function* () {
 });
 var initCommand = make31("init", {}, () => asUserError(init)).pipe(withHelp("Set up a git checkout for the other commands", "Makes it a jj repository colocated with git, unless it already is one, and copies git's name and email into the repository's jj config where jj has none. Where neither has them, set them with `jj config set --user`.", "Reads the default branch from `origin`, fetches and tracks it, and sets `trunk()` to it in the repository's config. jj's own `trunk()` guesses from branch names, so without this a default branch it doesn't guess would be the base of pull requests but not of local rebases. `submit`, `merge` and `sync` check that the two agree.", "Sets the `jj gh` alias to run `jj-octo` from `PATH`, in the repository's config, unless the repository has one, such as one that runs another build.", "Needs no GitHub token. Running it again changes nothing that is already set up. Run it again after the default branch changes on GitHub. Fails with what it couldn't set up, after setting up the rest. Where it can't make a colocated jj repository, such as in a git worktree, it sets up nothing else."));
 
-// src/clients/github/openapi.ts
-var responseOf = () => (schema) => schema;
-var bodyOf = (body) => bodyJsonUnsafe(body);
-
-// src/clients/github/types.ts
-var PullRequestNumberSchema = Number6.pipe(brand("PullRequestNumber"));
-var StackNumberSchema = Number6.pipe(brand("StackNumber"));
-
-// src/clients/github/client.ts
-class GitHubFailed extends TaggedError2("GitHubFailed") {
-}
-
-class GitHub extends Service()("jj-octo/GitHub") {
-}
-var CreatedPullRequest = responseOf()(Struct({ number: PullRequestNumberSchema }));
-var CreatedStack = responseOf()(Struct({ number: StackNumberSchema }));
-var PullRequests = responseOf()(ArraySchema(Struct({
-  base: Struct({ ref: String4 }),
-  body: NullOr(String4),
-  draft: optionalKey2(Boolean3),
-  number: PullRequestNumberSchema,
-  title: String4
-})));
-var ClosedPullRequests = responseOf()(ArraySchema(Struct({
-  head: Struct({ sha: String4 }),
-  merged_at: NullOr(String4)
-})));
-var StackedPullRequest = Struct({
-  number: PullRequestNumberSchema,
-  state: Literals(["closed", "open"])
-});
-var Stacks = responseOf()(ArraySchema(Struct({ number: StackNumberSchema, pull_requests: ArraySchema(StackedPullRequest) })));
-var RepositoryDetails = responseOf()(Struct({ default_branch: String4 }));
-var MergeRequest = Struct({
-  details: Struct({
-    message: String4,
-    uuid: optionalKey2(String4)
-  }),
-  status: Literals(["enqueued", "failed", "merged", "pending"])
-});
-var StartedMerge = responseOf()(MergeRequest);
-var MergeResult = responseOf()(MergeRequest);
-var GitHubLive = (repository, connection) => {
-  const repo = (path) => `/repos/${repository.owner}/${repository.name}${path}`;
-  return effect(GitHub, gen2(function* () {
-    const requestInit = match(connection.proxy, {
-      onNone: () => ({}),
-      onSome: ({ ca, url }) => match(ca, {
-        onNone: () => ({ proxy: url }),
-        onSome: (certificates) => ({ proxy: url, tls: { ca: certificates } })
-      })
-    });
-    const client = (yield* HttpClient).pipe(mapRequest((request) => request.pipe(prependUrl("https://api.github.com"), acceptJson, bearerToken(connection.token), setHeaders({
-      "user-agent": "jj-octo",
-      "x-github-api-version": "2022-11-28"
-    }))));
-    const send = (request) => client.execute(request).pipe(provideService2(RequestInit, requestInit), flatMap4((response) => response.status < 400 ? succeed6(response) : response.text.pipe(orElseSucceed2(() => ""), flatMap4((text) => fail6(new GitHubFailed({
-      message: `${request.method} ${request.url} returned ${response.status}: ${text}`
-    }))))), catchTag2("HttpClientError", (error) => fail6(new GitHubFailed({ message: error.message }))));
-    const json = (schema) => (request) => send(request).pipe(flatMap4(schemaBodyJson(schema)), catchTags2({
-      HttpClientError: (error) => fail6(new GitHubFailed({ message: error.message })),
-      SchemaError: (error) => fail6(new GitHubFailed({
-        message: `unexpected response to ${request.url}: ${error.message}`
-      }))
-    }));
-    const stackOf = (pullRequest) => json(Stacks)(get4(repo(`/stacks?pull_request=${pullRequest}`))).pipe(map7((stacks) => map(fromNullishOr(stacks[0]), (stack) => ({
-      number: stack.number,
-      open: stack.pull_requests.filter(({ state }) => state === "open").map(({ number }) => number)
-    }))));
-    const mergeRequest = (path) => json(MergeResult)(get4(repo(path)));
-    const fromBranch = (branch, state) => repo(`/pulls?state=${state}&head=${repository.owner}:${encodeURIComponent(branch)}`);
-    return {
-      addToStack: (stack, pullRequests) => send(post(repo(`/stacks/${stack}/add`)).pipe(bodyOf({ pull_requests: [...pullRequests] }))).pipe(asVoid2),
-      createPullRequest: ({ base, body, draft, head, title }) => json(CreatedPullRequest)(post(repo("/pulls")).pipe(bodyOf({ base, body, draft, head, title }))).pipe(map7(({ number }) => number)),
-      createStack: (pullRequests) => json(CreatedStack)(post(repo("/stacks")).pipe(bodyOf({ pull_requests: [...pullRequests] }))).pipe(map7(({ number }) => number)),
-      defaultBranch: json(RepositoryDetails)(get4(repo(""))).pipe(map7(({ default_branch }) => default_branch)),
-      mergePullRequest: (pullRequest) => send(put(repo(`/pulls/${pullRequest}/merge`)).pipe(bodyOf({ merge_method: "squash" }))).pipe(asVoid2),
-      mergeStack: (pullRequest) => gen2(function* () {
-        const started = yield* json(StartedMerge)(put(repo(`/pulls/${pullRequest}/merge-async`)).pipe(bodyOf({
-          merge_action: "default",
-          merge_method: "squash"
-        })));
-        const { uuid } = started.details;
-        if (uuid === undefined) {
-          return yield* new GitHubFailed({
-            message: `merging #${pullRequest} returned no request to follow`
-          });
-        }
-        const settled = yield* mergeRequest(`/pulls/${pullRequest}/merge-async/${uuid}`).pipe(repeat2({
-          schedule: spaced("5 seconds"),
-          until: ({ status }) => status !== "pending"
-        }));
-        if (settled.status === "merged" || settled.status === "enqueued") {
-          return settled.status;
-        }
-        return yield* new GitHubFailed({
-          message: `merging #${pullRequest} ended ${settled.status}: ${settled.details.message}`
-        });
-      }),
-      mergedHeads: (branch) => json(ClosedPullRequests)(get4(fromBranch(branch, "closed"))).pipe(map7((closed) => closed.filter(({ merged_at }) => merged_at !== null).map(({ head }) => head.sha))),
-      openPullRequest: (branch) => json(PullRequests)(get4(fromBranch(branch, "open"))).pipe(map7((found) => map(fromNullishOr(found[0]), ({ base, body, draft, number, title }) => ({
-        base: base.ref,
-        body: body ?? "",
-        draft: draft ?? false,
-        number,
-        title
-      })))),
-      setBase: (pullRequest, base) => send(patch(repo(`/pulls/${pullRequest}`)).pipe(bodyOf({ base }))).pipe(asVoid2),
-      setDescription: (pullRequest, { body, title }) => send(patch(repo(`/pulls/${pullRequest}`)).pipe(bodyOf({ body, title }))).pipe(asVoid2),
-      stackOf,
-      unstack: (stack) => send(post(repo(`/stacks/${stack}/unstack`))).pipe(asVoid2)
-    };
-  }));
-};
-
 // src/clients/github/connection.ts
 var authKey = "jj-octo.github-auth";
 var ownToken = gen2(function* () {
@@ -19003,115 +19009,24 @@ var syncDescription = ({ bookmark, description }, pullRequest, { ignoreClaudeCod
   })), exhaustive2);
 });
 
-// src/cli/gh/stack/publish.ts
-class SeveralStacks extends TaggedError2("SeveralStacks") {
-}
-var stackContaining = (pullRequests) => gen2(function* () {
-  const github = yield* GitHub;
-  const found = yield* all2(pullRequests.map((pullRequest) => github.stackOf(pullRequest)), { concurrency: "unbounded" });
-  const stacks = dedupeWith(found.flatMap((stack) => toArray(stack)), (a, b) => a.number === b.number);
-  if (stacks.length > 1) {
-    return yield* new SeveralStacks({
-      message: `the pull requests belong to stacks ${stacks.map(({ number }) => `#${number}`).join(" and ")}; unstack all but one`
-    });
-  }
-  return fromNullishOr(stacks[0]);
-});
-var register = (remaining, pullRequests) => gen2(function* () {
-  const github = yield* GitHub;
-  yield* value4(registrationFor(remaining, pullRequests)).pipe(tag3("Unchanged", () => void_3), tag3("Append", ({ pullRequests: added, stack }) => github.addToStack(stack, added).pipe(andThen2(error(`added ${added.join(", ")} to stack #${stack}`)))), tag3("Create", ({ pullRequests: all }) => github.createStack(all).pipe(flatMap4((stack) => error(`registered stack #${stack}`)))), exhaustive2);
-});
-var publish = (stack, { draft, overwriteDescriptions }) => gen2(function* () {
-  const github = yield* GitHub;
-  const jj = yield* Jj;
-  const bookmarks = stack.map(({ bookmark }) => bookmark);
-  const trunk = yield* github.defaultBranch;
-  const bases = basesFor(bookmarks, trunk);
-  const found = yield* all2(stack.map((change, index) => github.openPullRequest(change.bookmark).pipe(map7((pullRequest) => ({ base: bases[index] ?? trunk, change, pullRequest })))), { concurrency: "unbounded" });
-  const targets = yield* bookmarkTargets;
-  const pushedDescriptions = yield* descriptionsOf(bookmarks.flatMap((bookmark) => targets.get(bookmark)?.origin ?? []));
-  const ignoreClaudeCodeFooter = yield* ignoresClaudeCodeFooter;
-  const changes = [];
-  for (const entry of found) {
-    const pushed = targets.get(entry.change.bookmark)?.origin;
-    changes.push({
-      ...entry,
-      description: isNone2(entry.pullRequest) ? none2() : yield* syncDescription(entry.change, entry.pullRequest.value, {
-        ignoreClaudeCodeFooter,
-        overwriteDescriptions,
-        pushedDescription: (pushed === undefined ? undefined : pushedDescriptions.get(pushed)) ?? ""
-      })
-    });
-  }
-  const moving = changes.flatMap(({ base, pullRequest }) => isSome2(pullRequest) && pullRequest.value.base !== base ? [pullRequest.value] : []);
-  const wanted = changes.map(({ pullRequest }) => isSome2(pullRequest) ? some2(pullRequest.value.number) : none2());
-  const existing = yield* stackContaining(wanted.flatMap((number) => toArray(number)));
-  const dissolve = mustDissolve(existing, wanted, moving.length > 0);
-  if (dissolve && isSome2(existing)) {
-    yield* github.unstack(existing.value.number);
-    yield* error(`dissolved stack #${existing.value.number}`);
-  }
-  for (const { number } of moving.filter(({ base }) => base !== trunk)) {
-    yield* github.setBase(number, trunk);
-  }
-  const moved = new Set(moving.map(({ number }) => number));
-  for (const bookmark of bookmarks.filter((name) => targets.get(name)?.tracked !== true)) {
-    yield* jj.run(["bookmark", "track", `exact:${bookmark}`, "--remote", "origin"]);
-  }
-  yield* jj.run([
-    "git",
-    "push",
-    ...bookmarks.flatMap((bookmark) => ["--bookmark", `exact:${bookmark}`])
-  ]);
-  const numbers = [];
-  for (const { base, change, description, pullRequest } of changes) {
-    if (isNone2(pullRequest)) {
-      const created = yield* github.createPullRequest({
-        ...titleAndBody(change.description),
-        base,
-        draft,
-        head: change.bookmark
-      });
-      yield* error(`opened #${created} for ${change.bookmark}`);
-      numbers.push(created);
-    } else {
-      const { number } = pullRequest.value;
-      if (moved.has(number) && base !== trunk) {
-        yield* github.setBase(number, base);
-      }
-      if (isSome2(description)) {
-        yield* github.setDescription(number, titleAndBody(description.value));
-        yield* error(`updated the description of #${number}`);
-      }
-      numbers.push(number);
-    }
-  }
-  yield* register(dissolve ? none2() : existing, numbers);
-});
-var submit = (revision, options) => gen2(function* () {
-  yield* checkTrunk(yield* (yield* GitHub).defaultBranch);
-  yield* publish(yield* downstackChanges(revision), options);
-});
-var republish = (revision) => gen2(function* () {
-  if ((yield* changesIn(stackRevset(revision))).length === 0) {
-    return;
-  }
-  const stack = yield* stackChanges(revision);
-  const targets = yield* bookmarkTargets;
-  const top = stack.findLastIndex(({ bookmark }) => targets.get(bookmark)?.origin !== undefined);
-  if (top !== -1) {
-    yield* publish(stack.slice(0, top + 1), { draft: true, overwriteDescriptions: false });
-  }
-});
-
-// src/cli/gh/sync.ts
-var BEHIND_ROOTS = `(${STACK_ROOTS}) ~ children(trunk())`;
-var bookmarksBeforeFetch = gen2(function* () {
+// src/cli/gh/stack/combine.ts
+var pushedOf = (bookmarks) => bookmarks.filter(({ remote }) => remote !== undefined);
+var bookmarksBeforeFetch = (revset) => gen2(function* () {
   const targets = [...yield* bookmarkTargets];
-  const bottomFirst = lines2(yield* readLog("mutable() & bookmarks()", String.raw`commit_id ++ "\t" ++ change_id ++ "\n"`));
+  const bookmarked = `(${revset}) & bookmarks()`;
+  const bottomFirst = lines2(yield* readLog(bookmarked, String.raw`commit_id ++ "\t" ++ change_id ++ "\t" ++ current_working_copy ++ "\n"`));
+  const children = lines2(yield* readLog(`children(${bookmarked})`, String.raw`parents.map(|p| p.commit_id()).join(",") ++ "\t" ++ change_id ++ "\n"`)).map((line) => line.split("\t"));
   return bottomFirst.toReversed().flatMap((line) => {
-    const [commit = "", change = ""] = line.split("\t");
-    return targets.filter(([, { local }]) => local === commit).map(([name, { origin }]) => ({ change, local: commit, name, remote: origin }));
+    const [commit = "", change = "", workingCopy] = line.split("\t");
+    const above = children.flatMap(([parents = "", child = ""]) => parents.split(",").includes(commit) ? [child] : []);
+    return targets.filter(([, { local }]) => local === commit).map(([name, { origin }]) => ({
+      above,
+      change,
+      editing: workingCopy === "true",
+      local: commit,
+      name,
+      remote: origin
+    }));
   });
 });
 var localCommit = (change, remote, fetched) => gen2(function* () {
@@ -19122,22 +19037,31 @@ var localCommit = (change, remote, fetched) => gen2(function* () {
   }
   return local;
 });
-var combine4 = ({ change, local: localBefore, name, remote }, fetched) => gen2(function* () {
+var combine4 = ({ above, change, editing, local: localBefore, name, remote }, fetched) => gen2(function* () {
   const jj = yield* Jj;
   if (remote === undefined || fetched === undefined || fetched === remote) {
     return true;
   }
   const [local, ...others] = yield* localCommit(change, remote, fetched);
   if (local === undefined) {
+    if (editing) {
+      yield* jj.run(["edit", fetched]);
+    }
+    const moved = `(${anyOf(above.map((child) => `change_id(${child})`))}) ~ children(${fetched})`;
+    if ((yield* commitsAt(moved)).length > 0) {
+      yield* jj.run(["rebase", "--source", moved, "--destination", fetched]);
+      yield* error(`took GitHub's rewritten ${name}, and moved what was on it there`);
+    }
     return true;
   }
   if (others.length > 0) {
     return false;
   }
   const keepLocal = jj.run(["bookmark", "set", name, "-r", local, "--allow-backwards"]);
+  const held = `::(bookmarks() ~ ${bookmarkRevset(name)}) ~ ::${remote}`;
   const dropCopies = jj.run([
     "abandon",
-    `((::${fetched} | ::${remote}) & mutable()) ~ ::${bookmarkRevset(name)}`
+    `((::${fetched} | ::${remote}) & mutable()) ~ ::${bookmarkRevset(name)} ~ (${held})`
   ]);
   if ((yield* commitsAt(`${remote} & ::${fetched}`)).length > 0) {
     yield* keepLocal;
@@ -19155,6 +19079,9 @@ var combine4 = ({ change, local: localBefore, name, remote }, fetched) => gen2(f
   }
   if (localBefore === remote) {
     yield* jj.run(["rebase", "--source", `children(${local})`, "--destination", fetched]);
+    if (editing) {
+      yield* jj.run(["edit", fetched]);
+    }
     yield* jj.run(["abandon", local]);
     yield* error(`took GitHub's rewritten ${name}, which wasn't changed locally`);
     return true;
@@ -19169,6 +19096,9 @@ var combine4 = ({ change, local: localBefore, name, remote }, fetched) => gen2(f
   return false;
 });
 
+// src/cli/gh/stack/reconcile.ts
+var BEHIND_ROOTS = `(${STACK_ROOTS}) ~ children(trunk())`;
+
 class NotCombined extends TaggedError2("NotCombined") {
 }
 var rebaseStack = (root, required) => gen2(function* () {
@@ -19188,8 +19118,8 @@ var rebaseStack = (root, required) => gen2(function* () {
     String.raw`id ++ "\n"`
   ]));
   yield* jj.run(["rebase", "--source", root, "--destination", "trunk()", "--skip-emptied"]);
-  const rebased = ["none()", ...changes.map((change) => `change_id(${change})`)].join(" | ");
-  const untouched = ["none()", ...conflictedCommits].join(" | ");
+  const rebased = anyOf(changes.map((change) => `change_id(${change})`));
+  const untouched = anyOf(conflictedCommits);
   const conflictedNow = yield* changeIdsAt(`(conflicts() & (${rebased})) ~ (${untouched})`);
   const mayRestore = !changes.some((change) => required.includes(change));
   if (mayRestore && conflictedNow.some((change) => !conflicted.includes(change))) {
@@ -19197,23 +19127,49 @@ var rebaseStack = (root, required) => gen2(function* () {
     yield* error(`left "${name}" and the changes on it where they were: they conflict with the trunk`);
   }
 });
-var mergedOnGitHub = (bookmarks) => gen2(function* () {
+var notMerged = (merged) => (name) => merged.every(({ bookmark }) => bookmark !== name);
+var mergedHeadsOf = (bookmarks) => gen2(function* () {
   const github = yield* GitHub;
-  const merged = yield* forEach2(bookmarks.filter(({ remote }) => remote !== undefined), ({ change, local, name }) => github.mergedHeads(name).pipe(map7((heads) => heads.includes(local) ? [{ bookmark: name, changeId: change }] : [])), { concurrency: "unbounded" });
-  return merged.flat();
+  const pushed = pushedOf(bookmarks);
+  const heads = yield* forEach2(pushed, ({ name }) => github.mergedHeads(name), {
+    concurrency: "unbounded"
+  });
+  return Object.fromEntries(pushed.map(({ name }, index) => [name, heads[index] ?? []]));
 });
-var sync4 = (known = []) => gen2(function* () {
+var mergedIn = (bookmarks, heads) => gen2(function* () {
   const jj = yield* Jj;
-  const before = yield* bookmarksBeforeFetch;
-  const merged = [
-    ...known,
-    ...yield* mergedOnGitHub(before.filter(({ name }) => known.every(({ bookmark }) => bookmark !== name)))
-  ];
-  yield* jj.run(["git", "fetch"]);
-  for (const { bookmark } of merged) {
-    yield* jj.run(["bookmark", "forget", "--include-remotes", `exact:${bookmark}`]);
+  const merged = yield* forEach2(bookmarks, ({ change, local, name, remote }) => gen2(function* () {
+    const merges = heads[name] ?? [];
+    const rebasedOnly = remote !== undefined && merges.includes(remote) && (yield* jj.read(["interdiff", "--from", remote, "--to", local, "--summary"])).trim() === "";
+    return merges.includes(local) || rebasedOnly ? [{ bookmark: name, changeId: change }] : [];
+  }));
+  return merged.flat();
+});
+var mergedOnGitHub = (bookmarks) => flatMap4(mergedHeadsOf(bookmarks), (heads) => mergedIn(bookmarks, heads));
+var forget = (names) => gen2(function* () {
+  if (names.length > 0) {
+    const jj = yield* Jj;
+    yield* jj.run([
+      "bookmark",
+      "forget",
+      "--include-remotes",
+      ...names.map((name) => `exact:${name}`)
+    ]);
   }
-  const mergedRevset = `(${["none()", ...merged.map(({ changeId }) => `change_id(${changeId})`)].join(" | ")}) & mutable()`;
+});
+var reconcile = ({
+  before,
+  merged,
+  scope
+}) => gen2(function* () {
+  const jj = yield* Jj;
+  const branches = scope === "every stack" ? [] : [scope.trunk, ...pushedOf(before).map(({ name }) => name)].flatMap((branch) => [
+    "--branch",
+    `exact:${branch}`
+  ]);
+  yield* jj.run(["git", "fetch", ...branches]);
+  yield* forget(merged.map(({ bookmark }) => bookmark));
+  const mergedRevset = `(${anyOf(merged.map(({ changeId }) => `change_id(${changeId})`))}) & mutable()`;
   const required = yield* changeIdsAt(`(${mergedRevset}):: ~ (${mergedRevset})`);
   if (merged.length > 0) {
     yield* jj.run(["abandon", mergedRevset]);
@@ -19221,18 +19177,20 @@ var sync4 = (known = []) => gen2(function* () {
   }
   const fetched = yield* bookmarkTargets;
   const notCombined = [];
-  for (const bookmark of before.filter(({ name }) => merged.every((change) => change.bookmark !== name))) {
+  for (const bookmark of before.filter(({ name }) => notMerged(merged)(name))) {
     if (!(yield* combine4(bookmark, fetched.get(bookmark.name)?.origin))) {
       notCombined.push(bookmark.name);
     }
   }
-  for (const root of yield* commitsAt(BEHIND_ROOTS)) {
+  const roots = scope === "every stack" ? BEHIND_ROOTS : `(${BEHIND_ROOTS}) & ::(${anyOf([
+    ...scope.bookmarks.map((name) => bookmarkRevset(name)),
+    ...scope.unnamed.map((change) => `change_id(${change})`)
+  ])})`;
+  for (const root of yield* commitsAt(roots)) {
     yield* rebaseStack(root, required);
   }
-  const onTrunk = (yield* bookmarksAt("::trunk()")).filter((name) => before.some((bookmark) => bookmark.name === name));
-  for (const name of onTrunk) {
-    yield* jj.run(["bookmark", "forget", "--include-remotes", `exact:${name}`]);
-  }
+  const onStacks = new Set(scope === "every stack" ? before.map(({ name }) => name) : scope.bookmarks);
+  yield* forget((yield* bookmarksAt("::trunk()")).filter((name) => onStacks.has(name)));
   if (notCombined.length > 0) {
     yield* new NotCombined({
       message: [
@@ -19244,8 +19202,201 @@ var sync4 = (known = []) => gen2(function* () {
     });
   }
 });
+
+// src/cli/gh/stack/sync-stack.ts
+class BranchesDeleted extends TaggedError2("BranchesDeleted") {
+}
+var whyDeleted = (heads, { remote }) => {
+  if (remote !== undefined && heads.includes(remote)) {
+    return "its pushed commit merged, and the change was edited since";
+  }
+  return heads.length > 0 ? "a pull request from it merged, but not the commit pushed for this change" : "no pull request from it merged";
+};
+var changedOnGitHub = (bookmarks) => gen2(function* () {
+  const pushed = pushedOf(bookmarks);
+  if (pushed.length === 0) {
+    return { changed: [], deleted: [] };
+  }
+  const git = yield* Git;
+  const gitDirectory = (yield* (yield* Jj).read(["git", "root"])).trim();
+  const output = yield* git.read([
+    "--git-dir",
+    gitDirectory,
+    "ls-remote",
+    "origin",
+    ...pushed.map(({ name }) => `refs/heads/${name}`)
+  ]);
+  const onGitHub = new Map(lines2(output).map((line) => {
+    const [commit = "", ref = ""] = line.split("\t");
+    return [ref.replace(/^refs\/heads\//u, ""), commit];
+  }));
+  return {
+    changed: pushed.filter(({ name, remote }) => onGitHub.has(name) && onGitHub.get(name) !== remote).map(({ name }) => name),
+    deleted: pushed.filter(({ name }) => !onGitHub.has(name))
+  };
+});
+var syncStack = (revision, trunk) => gen2(function* () {
+  const downstack = downstackRevset(revision);
+  const before = yield* bookmarksBeforeFetch(downstack);
+  const [heads, onGitHub] = yield* all2([mergedHeadsOf(before), changedOnGitHub(before)], {
+    concurrency: "unbounded"
+  });
+  const merged = yield* mergedIn(before, heads);
+  const changed = onGitHub.changed.filter(notMerged(merged));
+  const deleted = onGitHub.deleted.filter(({ name }) => notMerged(merged)(name));
+  if (deleted.length > 0) {
+    return yield* new BranchesDeleted({
+      message: [
+        "these branches were deleted on GitHub, so nothing was changed:",
+        ...deleted.map((bookmark) => `${bookmark.name}: ${whyDeleted(heads[bookmark.name] ?? [], bookmark)}`),
+        "to push a change again, run `jj bookmark forget --include-remotes <name>`, then `jj bookmark create <name> -r <change>`; to drop one, run `jj abandon <change>`"
+      ].join(`
+`)
+    });
+  }
+  const found = [
+    ...merged.map(({ bookmark }) => `${bookmark} merged`),
+    ...changed.map((name) => `${name} changed`)
+  ];
+  if (found.length === 0) {
+    return false;
+  }
+  yield* error(`on GitHub, ${found.join(", ")}; syncing the stack first`);
+  const whole = stackRevset(revision);
+  yield* reconcile({
+    before,
+    merged,
+    scope: {
+      bookmarks: yield* bookmarksAt(whole),
+      trunk,
+      unnamed: yield* changeIdsAt(`((${whole}) | (@ & children(${whole}))) ~ bookmarks()`)
+    }
+  });
+  return true;
+});
+
+// src/cli/gh/stack/publish.ts
+class SeveralStacks extends TaggedError2("SeveralStacks") {
+}
+var stackContaining = (pullRequests) => gen2(function* () {
+  const github = yield* GitHub;
+  const found = yield* all2(pullRequests.map((pullRequest) => github.stackOf(pullRequest)), { concurrency: "unbounded" });
+  const stacks = dedupeWith(found.flatMap((stack) => toArray(stack)), (a, b) => a.number === b.number);
+  if (stacks.length > 1) {
+    return yield* new SeveralStacks({
+      message: `the pull requests belong to stacks ${stacks.map(({ number }) => `#${number}`).join(" and ")}; unstack all but one`
+    });
+  }
+  return fromNullishOr(stacks[0]);
+});
+var register = (remaining, pullRequests) => gen2(function* () {
+  const github = yield* GitHub;
+  yield* value4(registrationFor(remaining, pullRequests)).pipe(tag3("Unchanged", () => void_3), tag3("Append", ({ pullRequests: added, stack }) => github.addToStack(stack, added).pipe(andThen2(error(`added ${added.join(", ")} to stack #${stack}`)))), tag3("Create", ({ pullRequests: all }) => github.createStack(all).pipe(flatMap4((stack) => error(`registered stack #${stack}`)))), exhaustive2);
+});
+var publish = (stack, { draft, overwriteDescriptions, trunk }) => gen2(function* () {
+  const github = yield* GitHub;
+  const jj = yield* Jj;
+  const bookmarks = stack.map(({ bookmark }) => bookmark);
+  const bases = basesFor(bookmarks, trunk);
+  const found = yield* all2(stack.map((change, index) => github.openPullRequest(change.bookmark).pipe(map7((pullRequest) => ({ base: bases[index] ?? trunk, change, pullRequest })))), { concurrency: "unbounded" });
+  const targets = yield* bookmarkTargets;
+  const pushedDescriptions = yield* descriptionsOf(bookmarks.flatMap((bookmark) => targets.get(bookmark)?.origin ?? []));
+  const ignoreClaudeCodeFooter = yield* ignoresClaudeCodeFooter;
+  const changes = [];
+  for (const entry of found) {
+    const pushed = targets.get(entry.change.bookmark)?.origin;
+    changes.push({
+      ...entry,
+      description: isNone2(entry.pullRequest) ? none2() : yield* syncDescription(entry.change, entry.pullRequest.value, {
+        ignoreClaudeCodeFooter,
+        overwriteDescriptions,
+        pushedDescription: (pushed === undefined ? undefined : pushedDescriptions.get(pushed)) ?? ""
+      })
+    });
+  }
+  const moving = changes.flatMap(({ base, pullRequest }) => isSome2(pullRequest) && pullRequest.value.base !== base ? [pullRequest.value] : []);
+  const wanted = changes.map(({ pullRequest }) => isSome2(pullRequest) ? some2(pullRequest.value.number) : none2());
+  const existing = yield* stackContaining(wanted.flatMap((number) => toArray(number)));
+  const dissolve = mustDissolve(existing, wanted, moving.length > 0);
+  if (dissolve && isSome2(existing)) {
+    yield* github.unstack(existing.value.number);
+    yield* error(`dissolved stack #${existing.value.number}`);
+  }
+  for (const { number } of moving.filter(({ base }) => base !== trunk)) {
+    yield* github.setBase(number, trunk);
+  }
+  const moved = new Set(moving.map(({ number }) => number));
+  for (const bookmark of bookmarks.filter((name) => targets.get(name)?.tracked !== true)) {
+    yield* jj.run(["bookmark", "track", `exact:${bookmark}`, "--remote", "origin"]);
+  }
+  yield* jj.run([
+    "git",
+    "push",
+    ...bookmarks.flatMap((bookmark) => ["--bookmark", `exact:${bookmark}`])
+  ]);
+  const numbers = [];
+  for (const { base, change, description, pullRequest } of changes) {
+    if (isNone2(pullRequest)) {
+      const created = yield* github.createPullRequest({
+        ...titleAndBody(change.description),
+        base,
+        draft,
+        head: change.bookmark
+      });
+      yield* error(`opened #${created} for ${change.bookmark}`);
+      numbers.push(created);
+    } else {
+      const { number } = pullRequest.value;
+      if (moved.has(number) && base !== trunk) {
+        yield* github.setBase(number, base);
+      }
+      if (isSome2(description)) {
+        yield* github.setDescription(number, titleAndBody(description.value));
+        yield* error(`updated the description of #${number}`);
+      }
+      numbers.push(number);
+    }
+  }
+  yield* register(dissolve ? none2() : existing, numbers);
+});
+var submit = (revision, options) => gen2(function* () {
+  const trunk = yield* checkedTrunk;
+  const downstack = yield* downstackChanges(revision);
+  if (!(yield* syncStack(revision, trunk))) {
+    yield* publish(downstack, { ...options, trunk });
+    return;
+  }
+  const left = yield* bookmarksAt(anyOf(downstack.map(({ bookmark }) => bookmarkRevset(bookmark))));
+  const top = downstack.findLast(({ bookmark }) => left.includes(bookmark));
+  if (top === undefined) {
+    yield* error(`nothing left to submit: no bookmark of the stack is left after the sync`);
+    return;
+  }
+  yield* publish(yield* downstackChanges(bookmarkRevset(top.bookmark)), { ...options, trunk });
+});
+var republish = (revision, trunk) => gen2(function* () {
+  if ((yield* changesIn(stackRevset(revision))).length === 0) {
+    return;
+  }
+  const stack = yield* stackChanges(revision);
+  const targets = yield* bookmarkTargets;
+  const top = stack.findLastIndex(({ bookmark }) => targets.get(bookmark)?.origin !== undefined);
+  if (top !== -1) {
+    yield* publish(stack.slice(0, top + 1), { draft: true, overwriteDescriptions: false, trunk });
+  }
+});
+
+// src/cli/gh/sync.ts
+var sync4 = (known = []) => gen2(function* () {
+  const before = yield* bookmarksBeforeFetch("mutable()");
+  const merged = [
+    ...known,
+    ...yield* mergedOnGitHub(before.filter(({ name }) => notMerged(known)(name)))
+  ];
+  yield* reconcile({ before, merged, scope: "every stack" });
+});
 var syncCommand = make31("sync", {}, () => asUserError(gen2(function* () {
-  yield* checkTrunk(yield* (yield* GitHub).defaultBranch);
+  yield* checkedTrunk;
   yield* sync4();
 }).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Fetch, and rebase every change onto the trunk", "Fetches, then rebases every change that isn't merged yet onto the trunk, keeping each on the changes below it. A change whose pull request GitHub merged is abandoned and its bookmark forgotten, unless it was edited after the merge.", "A stack that would conflict with the trunk is left where it was, and named. Rebase it yourself with `jj rebase` when you want to resolve it. The rest of a stack whose changes merged is rebased even where it conflicts, and the conflict is recorded in the change.", "Commits added to a branch on GitHub are squashed into the branch's local change, whether or not that change was also edited locally. Where GitHub only rebased a branch, the local change is kept.", "Fails before fetching if `trunk()` isn't GitHub's default branch, which `jj-octo init` sets.", "Pushes nothing. Run `jj gh submit` to update the pull requests of a change and the ones below it."));
 
@@ -19281,8 +19432,7 @@ var mergeOnGitHub = ({ base, number }, trunk) => gen2(function* () {
   return "merged";
 });
 var merge5 = (revision) => gen2(function* () {
-  const trunk = yield* (yield* GitHub).defaultBranch;
-  yield* checkTrunk(trunk);
+  const trunk = yield* checkedTrunk;
   const changes = yield* downstackChanges(revision);
   const top = changes.at(-1)?.bookmark ?? "";
   const targets = yield* bookmarkTargets;
@@ -19301,7 +19451,7 @@ var merge5 = (revision) => gen2(function* () {
     yield* sync4(changes);
     for (const bookmark of above) {
       if ((yield* commitsAt(bookmarkRevset(bookmark))).length > 0) {
-        yield* republish(bookmarkRevset(bookmark));
+        yield* republish(bookmarkRevset(bookmark), trunk);
         break;
       }
     }
@@ -19314,7 +19464,7 @@ var submitCommand = make31("submit", {
   overwriteDescriptions: Boolean6("overwrite-descriptions").pipe(withDefault5(false), withDescription2("Where a description changed both locally and on GitHub, send the local one instead of merging the two")),
   publish: Boolean6("publish").pipe(withDefault5(false), withDescription2("Open new pull requests ready for review, instead of as drafts")),
   revision: revisionFlag("The top change to submit")
-}, ({ overwriteDescriptions, publish, revision }) => asUserError(submit(revision, { draft: !publish, overwriteDescriptions }).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Push a change and the ones below it, and open their pull requests", "Pushes the bookmark of each of those changes. An empty working copy means the change below it, so from the top of a stack this submits all of it. Opens a pull request for each branch that has none, with the title and body from the change's description. Points each pull request at the branch below it, and the bottom one at the default branch.", "New pull requests are opened as drafts, or ready for review with `--publish`. The flag doesn't change a pull request that already exists.", "Keeps each pull request's title and body the same as its change's description. A description edited on GitHub is written into the change, one edited locally is sent to the pull request, and edits on both sides are merged line by line. Edits to the same lines stop the submit before anything is pushed.", "Registers the pull requests as one GitHub stack. A stack of one change is a single pull request, which GitHub has no stack for.", "If changes were reordered, inserted or dropped since the last submit, the GitHub stack is dissolved and registered again under a new number. The pull requests stay open, including the one of a dropped change."));
+}, ({ overwriteDescriptions, publish, revision }) => asUserError(submit(revision, { draft: !publish, overwriteDescriptions }).pipe(provide3(GitHubFromOrigin)))).pipe(withHelp("Push a change and the ones below it, and open their pull requests", "Pushes the bookmark of each of those changes. An empty working copy means the change below it, so from the top of a stack this submits all of it. Opens a pull request for each branch that has none, with the title and body from the change's description. Points each pull request at the branch below it, and the bottom one at the default branch.", "New pull requests are opened as drafts, or ready for review with `--publish`. The flag doesn't change a pull request that already exists.", "Keeps each pull request's title and body the same as its change's description. A description edited on GitHub is written into the change, one edited locally is sent to the pull request, and edits on both sides are merged line by line. Edits to the same lines stop the submit before anything is pushed.", "First, where any of those changes' pull requests merged or any of their branches changed on GitHub, syncs their stack as `jj gh sync` does, and leaves other stacks alone. That drops the merged changes, takes what GitHub added to the branches, and rebases the rest onto the trunk, so the push doesn't undo GitHub's work.", "Stops before changing anything where one of their branches was deleted on GitHub and their change doesn't count as merged: no pull request from it merged, another commit merged, or the change was edited since. It says how to push the change again, or drop it.", "Registers the pull requests as one GitHub stack. A stack of one change is a single pull request, which GitHub has no stack for.", "If changes were reordered, inserted or dropped since the last submit, the GitHub stack is dissolved and registered again under a new number. The pull requests stay open, including the one of a dropped change."));
 
 // src/cli/gh/command.ts
 var jjGhCommand = make31("jj gh").pipe(withSubcommands([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jj-octo",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "A jj subcommand for GitHub that supports stacked pull requests and works in Claude Code cloud sessions",
   "license": "MIT",
   "repository": {