jj-octo 0.5.0 → 0.7.0

package/README.md

@@ -28,6 +28,8 @@ mise use --global github:kkom/jj-octo@X.Y.Z
 
 Then run `jj-octo init` once in each checkout. It makes the checkout a jj repository colocated with git, makes GitHub's default branch `trunk()`, and sets the `jj gh` alias.
 
+Run `jj-octo init` again after upgrading jj-octo, to set up what the new version needs. `jj-octo doctor` reports what isn't set up, and changes nothing.
+
 ## GitHub access
 
 `jj-octo` reads the repository from the `origin` remote.
@@ -50,18 +52,6 @@ jj config set --repo jj-octo.ignore-claude-code-footer true
 
 There, the [GitHub proxy](https://code.claude.com/docs/en/cloud-environments#github-proxy) carries all GitHub traffic. It serves GitHub API requests only for the repositories attached to the session, and rejects GraphQL requests. That's why `jj-octo` uses only GitHub's REST API, while `gh pr` and other tools that depend on GraphQL fail there.
 
-mise reads this repository's releases through the GitHub API, so it can't install them unless the session has this repository attached. Install the npm package instead:
-
-```toml
-[tools]
-bun = "A.B.C"
-
-[tools."npm:jj-octo"]
-version = "X.Y.Z"
-# mise holds back a package that is new or rarely downloaded, and this approves it.
-allow_low_downloads = true
-```
-
 The session sets `HTTPS_PROXY`, `NODE_EXTRA_CA_CERTS`, and `GH_TOKEN` to the placeholder `proxy-injected`. The GitHub proxy replaces the placeholder with your real credentials. So `jj-octo` works there with its default settings.
 
 ### In a self-hosted environment

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.5.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: {
@@ -18343,12 +18343,30 @@ var gitLayer = ({ cwd, env } = {}) => effect(Git, gen2(function* () {
         handle.exitCode
       ], { concurrency: "unbounded" });
       return code === 0 ? stdout : yield* new GitFailed({
+        exitCode: code,
         message: `git ${args.join(" ")} failed${stderr.trim() === "" ? "" : `: ${stderr.trim()}`}`
       });
     })).pipe(catchTag2("PlatformError", (error) => fail6(new GitFailed({ message: `git ${args.join(" ")} failed: ${error.message}` }))))
   };
 }));
 var GitLive = gitLayer();
+var gitConfig = (args) => gen2(function* () {
+  const git = yield* Git;
+  const value = yield* git.read(["config", ...args]).pipe(catch_2((error) => error.exitCode === 1 ? succeed6("") : fail6(error)));
+  return value.trim();
+});
+var gitDirectories = gen2(function* () {
+  const git = yield* Git;
+  const [topLevel = "", gitDirectory = "", commonDirectory = ""] = (yield* git.read([
+    "rev-parse",
+    "--path-format=absolute",
+    "--show-toplevel",
+    "--git-dir",
+    "--git-common-dir"
+  ])).split(`
+`);
+  return { commonDirectory, gitDirectory, topLevel };
+});
 
 // src/clients/jj.ts
 class JjFailed extends TaggedError2("JjFailed") {
@@ -18376,6 +18394,42 @@ var jjLayer = ({ cwd, env, quiet = false } = {}) => effect(Jj, gen2(function* ()
   return { read, run };
 }));
 var JjLive = jjLayer();
+var ENTRY = String.raw`json(name) ++ " " ++ json(value) ++ "\n"`;
+var readJjConfig = (key, { repo = false } = {}) => gen2(function* () {
+  const jj = yield* Jj;
+  const scope = repo ? ["--repo"] : [];
+  const output = yield* jj.read(["config", "list", ...scope, key, "-T", ENTRY]);
+  const lines = output.split(`
+`).filter((line) => line !== "");
+  const prefix = `${JSON.stringify(key)} `;
+  if (lines.some((line) => !line.startsWith(prefix))) {
+    return yield* new JjFailed({ message: `${key} is a table; set it to a single value` });
+  }
+  const [line] = lines;
+  return line === undefined ? undefined : JSON.parse(line.slice(prefix.length));
+});
+var jjConfig = (key) => gen2(function* () {
+  const value = yield* readJjConfig(key);
+  if (value === undefined || typeof value === "string") {
+    return value ?? "";
+  }
+  return yield* new JjFailed({
+    message: `${key} is ${JSON.stringify(value)}; set it to a string`
+  });
+});
+var jjFlag = (key) => gen2(function* () {
+  const value = yield* readJjConfig(key);
+  if (value === undefined || typeof value === "boolean") {
+    return value === true;
+  }
+  return yield* new JjFailed({
+    message: `${key} is ${JSON.stringify(value)}; set it to true or false`
+  });
+});
+var setJjConfig = (key, value) => gen2(function* () {
+  const jj = yield* Jj;
+  yield* jj.run(["config", "set", "--repo", key, JSON.stringify(value)]);
+});
 
 // src/cli/gh/stack/changes.ts
 class NotAStack extends TaggedError2("NotAStack") {
@@ -18385,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 !== "");
@@ -18490,100 +18545,6 @@ var chain = (revset, revision) => gen2(function* () {
 var stackChanges = (revision) => chain(stackRevset(revision), revision);
 var downstackChanges = (revision) => chain(downstackRevset(revision), revision);
 
-// src/cli/gh/stack/trunk.ts
-class TrunkMismatch extends TaggedError2("TrunkMismatch") {
-}
-var trunkRevset = (branch) => `${JSON.stringify(branch)}@origin`;
-var checkTrunk = (branch) => gen2(function* () {
-  if ((yield* commitsAt(`trunk() & present(${trunkRevset(branch)})`)).length === 0) {
-    yield* new TrunkMismatch({
-      message: `trunk() isn't ${branch}@origin, GitHub's default branch; run \`jj gh init\``
-    });
-  }
-});
-
-// src/cli/gh/init.ts
-var colocate = gen2(function* () {
-  const fs = yield* FileSystem;
-  const git = yield* Git;
-  const jj = yield* Jj;
-  const resolve = (output) => fs.realPath(output.trim()).pipe(orElseSucceed2(() => ""));
-  const root = yield* resolve(yield* git.read(["rev-parse", "--show-toplevel"]));
-  const jjRoot = yield* jj.read(["root"]).pipe(flatMap4(resolve), orElseSucceed2(() => ""));
-  if (jjRoot !== root) {
-    const [gitDirectory, commonDirectory] = (yield* git.read([
-      "rev-parse",
-      "--path-format=absolute",
-      "--git-dir",
-      "--git-common-dir"
-    ])).split(`
-`);
-    if (gitDirectory !== commonDirectory) {
-      yield* new GitFailed({
-        message: "this is a git worktree, where jj would make a second repository; run `jj workspace add` in the main checkout instead"
-      });
-    }
-    yield* jj.run(["git", "init", "--colocate", root]);
-  }
-});
-var copyIdentity = gen2(function* () {
-  const git = yield* Git;
-  const jj = yield* Jj;
-  for (const key of ["user.name", "user.email"]) {
-    const own = (yield* jj.read(["config", "get", key])).trim();
-    const value = (yield* git.read(["config", key]).pipe(orElseSucceed2(() => ""))).trim();
-    if (own === "" && value !== "") {
-      yield* jj.run(["config", "set", "--repo", key, JSON.stringify(value)]);
-    }
-  }
-});
-var defaultBranch = gen2(function* () {
-  const git = yield* Git;
-  const output = yield* git.read(["ls-remote", "--symref", "origin", "HEAD"]);
-  const branch = /^ref: refs\/heads\/(?<branch>\S+)\tHEAD$/mu.exec(output)?.groups?.["branch"];
-  if (branch === undefined) {
-    return yield* new GitFailed({ message: "origin names no default branch" });
-  }
-  return branch;
-});
-var setTrunk = gen2(function* () {
-  const jj = yield* Jj;
-  const branch = yield* defaultBranch;
-  if ((yield* commitsAt(`present(${trunkRevset(branch)})`)).length === 0) {
-    yield* jj.run(["git", "fetch", "--remote", "origin", "--branch", `exact:${branch}`]);
-  }
-  if ((yield* bookmarkTargets).get(branch)?.tracked !== true) {
-    yield* jj.run(["bookmark", "track", `exact:${branch}`, "--remote", "origin"]);
-  }
-  yield* jj.run([
-    "config",
-    "set",
-    "--repo",
-    'revset-aliases."trunk()"',
-    JSON.stringify(trunkRevset(branch))
-  ]);
-  return branch;
-});
-var init = gen2(function* () {
-  const jj = yield* Jj;
-  yield* colocate;
-  yield* copyIdentity;
-  const anonymous = 'mutable() & (author_name(exact:"") | author_email(exact:""))';
-  if ((yield* commitsAt(anonymous)).length > 0) {
-    yield* jj.run(["metaedit", "--quiet", "--update-author", "-r", anonymous]);
-  }
-  const branch = yield* setTrunk;
-  yield* jj.run([
-    "config",
-    "set",
-    "--repo",
-    "aliases.gh",
-    JSON.stringify(["util", "exec", "--", "jj-octo"])
-  ]);
-  yield* error(`set up jj, with trunk() as ${branch}@origin`);
-});
-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.", "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. Set it again afterwards to run 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."));
-
 // src/clients/github/openapi.ts
 var responseOf = () => (schema) => schema;
 var bodyOf = (body) => bodyJsonUnsafe(body);
@@ -18699,6 +18660,155 @@ var GitHubLive = (repository, connection) => {
   }));
 };
 
+// src/cli/gh/stack/trunk.ts
+class TrunkMismatch extends TaggedError2("TrunkMismatch") {
+}
+var trunkRevset = (branch) => `${JSON.stringify(branch)}@origin`;
+var checkTrunk = (branch) => gen2(function* () {
+  if ((yield* commitsAt(`trunk() & present(${trunkRevset(branch)})`)).length === 0) {
+    yield* new TrunkMismatch({
+      message: `trunk() isn't ${branch}@origin, GitHub's default branch; run \`jj-octo init\``
+    });
+  }
+});
+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") {
+}
+var forInit = (message) => ({ byInit: true, message });
+var advice = ({ byInit, message }) => byInit ? `${message}; run \`jj-octo init\`` : message;
+var defaultBranch = gen2(function* () {
+  const git = yield* Git;
+  const output = yield* git.read(["ls-remote", "--symref", "origin", "HEAD"]);
+  const branch = /^ref: refs\/heads\/(?<branch>\S+)\tHEAD$/mu.exec(output)?.groups?.["branch"];
+  if (branch === undefined) {
+    return yield* new GitFailed({ message: "origin names no default branch" });
+  }
+  return branch;
+});
+var checkout = gen2(function* () {
+  const fs = yield* FileSystem;
+  const { commonDirectory, gitDirectory, topLevel: root } = yield* gitDirectories;
+  const isColocated = yield* fs.exists(`${root}/.jj`).pipe(orElseSucceed2(() => false));
+  return { isColocated, isWorktree: gitDirectory !== commonDirectory, root };
+});
+var colocated = {
+  check: map7(checkout, ({ isColocated, isWorktree }) => {
+    const problem = isWorktree ? {
+      byInit: false,
+      message: "this is a git worktree, where jj would make a second repository; run `jj workspace add` in the main checkout instead"
+    } : forInit("this checkout isn't a jj repository colocated with git");
+    return isColocated ? undefined : problem;
+  }),
+  fix: gen2(function* () {
+    const jj = yield* Jj;
+    const { root } = yield* checkout;
+    yield* jj.run(["git", "init", "--colocate", root]);
+  })
+};
+var IDENTITY = ["user.name", "user.email"];
+var identity2 = (key) => ({
+  check: gen2(function* () {
+    const inJj = (yield* jjConfig(key)) !== "";
+    const inGit = !inJj && (yield* gitConfig([key])) !== "";
+    const problem = inGit ? forInit(`jj has no ${key}, which git has`) : {
+      byInit: false,
+      message: `neither jj nor git has ${key}; set it with \`jj config set --user ${key}\``
+    };
+    return inJj ? undefined : problem;
+  }),
+  fix: gen2(function* () {
+    yield* setJjConfig(key, yield* gitConfig([key]));
+  })
+});
+var ANONYMOUS = 'mutable() & (author_name(exact:"") | author_email(exact:""))';
+var authors = {
+  check: gen2(function* () {
+    const values = yield* forEach2(IDENTITY, jjConfig);
+    const hasIdentity = values.every((value) => value !== "");
+    const isAnonymous = hasIdentity && (yield* commitsAt(ANONYMOUS)).length > 0;
+    return isAnonymous ? forInit("some mutable changes have no author") : undefined;
+  }),
+  fix: gen2(function* () {
+    const jj = yield* Jj;
+    yield* jj.run(["metaedit", "--quiet", "--update-author", "-r", ANONYMOUS]);
+  })
+};
+var isTracked = (branch) => map7(commitsAt(`tracked_remote_bookmarks(exact:${JSON.stringify(branch)}, remote=exact:"origin")`), (commits) => commits.length > 0);
+var namesTrunk = (branch) => map7(jjConfig('revset-aliases."trunk()"'), (alias) => alias === trunkRevset(branch) || alias === `${branch}@origin`);
+var trunk = (branchOnOrigin) => ({
+  check: gen2(function* () {
+    const branch = yield* branchOnOrigin;
+    return (yield* isTracked(branch)) && (yield* namesTrunk(branch)) ? undefined : forInit(`trunk() isn't ${branch}@origin, GitHub's default branch, fetched and tracked`);
+  }),
+  fix: gen2(function* () {
+    const jj = yield* Jj;
+    const branch = yield* branchOnOrigin;
+    if ((yield* commitsAt(`present(${trunkRevset(branch)})`)).length === 0) {
+      yield* jj.run(["git", "fetch", "--remote", "origin", "--branch", `exact:${branch}`]);
+    }
+    if (!(yield* isTracked(branch))) {
+      yield* jj.run(["bookmark", "track", `exact:${branch}`, "--remote", "origin"]);
+    }
+    if (!(yield* namesTrunk(branch))) {
+      yield* setJjConfig('revset-aliases."trunk()"', trunkRevset(branch));
+    }
+  })
+});
+var alias = {
+  check: map7(readJjConfig("aliases.gh", { repo: true }), (value) => value === undefined ? forInit("`jj gh` isn't set up") : undefined),
+  fix: setJjConfig("aliases.gh", ["util", "exec", "--", "jj-octo"])
+};
+var setup = map7(cached2(defaultBranch), (branch) => ({
+  branch,
+  steps: [...IDENTITY.map((key) => identity2(key)), authors, trunk(branch), alias]
+}));
+var runSteps = (run) => gen2(function* () {
+  const { branch, steps } = yield* setup;
+  const notColocated = yield* run(colocated);
+  const found = notColocated === undefined ? yield* forEach2(steps, (step) => run(step)) : [notColocated];
+  const problems = new Set(found.filter((problem) => problem !== undefined));
+  return { branch, problems: [...problems] };
+});
+
+// src/cli/gh/doctor.ts
+var find = ({ check }) => check.pipe(map7((problem) => problem === undefined ? undefined : advice(problem)), catch_2((error2) => succeed6(`could not check: ${error2.message}`)));
+var problems = map7(runSteps(find), ({ problems: found }) => found);
+var doctor = gen2(function* () {
+  const found = yield* problems;
+  if (found.length > 0) {
+    yield* new NotSetUp({ message: found.join(`
+`) });
+  }
+  yield* error("set up for jj-octo");
+});
+var doctorCommand = make31("doctor", {}, () => asUserError(doctor)).pipe(withHelp("Check that a checkout is set up for the other commands", "Runs the checks of everything `init` sets up or requires, and changes nothing. Fails with each problem, and what fixes it."));
+
+// src/cli/gh/init.ts
+var fixed = ({ check, fix }) => gen2(function* () {
+  const found = yield* check;
+  if (found?.byInit !== true) {
+    return found?.message;
+  }
+  yield* fix;
+  const problem = yield* check;
+  return problem?.byInit === true ? `${problem.message}, though init set it up` : problem?.message;
+}).pipe(catch_2((error2) => succeed6(error2.message)));
+var init = gen2(function* () {
+  const { branch, problems } = yield* runSteps(fixed);
+  if (problems.length > 0) {
+    yield* new NotSetUp({ message: problems.join(`
+`) });
+  }
+  yield* error(`set up jj, with trunk() as ${yield* branch}@origin`);
+});
+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/connection.ts
 var authKey = "jj-octo.github-auth";
 var ownToken = gen2(function* () {
@@ -18711,8 +18821,7 @@ var ownToken = gen2(function* () {
   return stored === "" ? yield* fail6("no token") : make20(stored);
 }).pipe(mapError3(() => new GitHubFailed({ message: "no GitHub token: set GH_TOKEN, or run `gh auth login`" })));
 var gitSetting = (name) => gen2(function* () {
-  const git = yield* Git;
-  const value = (yield* git.read(["config", "--get-urlmatch", name, "https://github.com"]).pipe(orElseSucceed2(() => ""))).trim();
+  const value = yield* gitConfig(["--get-urlmatch", name, "https://github.com"]).pipe(mapError3(({ message }) => new GitHubFailed({ message })));
   return value === "" ? none2() : some2(value);
 });
 var gitProxy = gen2(function* () {
@@ -18735,8 +18844,7 @@ var gitProxy = gen2(function* () {
   return connection;
 });
 var connection = gen2(function* () {
-  const jj = yield* Jj;
-  const auth = (yield* jj.read(["config", "get", authKey]).pipe(orElseSucceed2(() => ""))).trim();
+  const auth = yield* jjConfig(authKey).pipe(mapError3(({ message }) => new GitHubFailed({ message })));
   switch (auth) {
     case "":
     case "token": {
@@ -18864,24 +18972,7 @@ var descriptionSyncFor = ({
 class DescriptionConflict extends TaggedError2("DescriptionConflict") {
 }
 var ignoreClaudeCodeFooterKey = "jj-octo.ignore-claude-code-footer";
-var ignoresClaudeCodeFooter = gen2(function* () {
-  const jj = yield* Jj;
-  const value = (yield* jj.read(["config", "get", ignoreClaudeCodeFooterKey]).pipe(orElseSucceed2(() => ""))).trim();
-  switch (value) {
-    case "":
-    case "false": {
-      return false;
-    }
-    case "true": {
-      return true;
-    }
-    default: {
-      return yield* new JjFailed({
-        message: `${ignoreClaudeCodeFooterKey} is ${JSON.stringify(value)}; set it to true or false`
-      });
-    }
-  }
-});
+var ignoresClaudeCodeFooter = jjFlag(ignoreClaudeCodeFooterKey);
 var descriptionsOf = (commits) => commits.length === 0 ? succeed6(new Map) : readLog(commits.join(" | "), String.raw`commit_id ++ "\t" ++ description.escape_json() ++ "\n"`).pipe(map7((output) => new Map(lines2(output).map((line) => {
   const [commit = "", json = '""'] = line.split("\t");
   const parsed = JSON.parse(json);
@@ -18918,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* () {
@@ -19037,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;
@@ -19070,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;
@@ -19084,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* () {
@@ -19103,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))) {
@@ -19112,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]);
@@ -19136,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: [
@@ -19159,10 +19202,203 @@ 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 gh init` sets.", "Pushes nothing. Run `jj gh submit` to update the pull requests of a change and the ones below it."));
+}).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."));
 
 // src/cli/gh/merge.ts
 class NotMergeable extends TaggedError2("NotMergeable") {
@@ -19196,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;
@@ -19216,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;
       }
     }
@@ -19229,10 +19464,17 @@ 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([initCommand, logCommand, mergeCommand, submitCommand, syncCommand]), withHelp("Commands for publishing jj changes as GitHub pull requests", "A stack is a chain of changes, each published as one pull request on the branch its bookmark names. Each pull request targets the branch of the change below it, so it shows only that change's diff. A single change is a stack of one, and is published as an ordinary pull request.", "The stack of a change is every change connected to it through mutable changes. An empty working copy with no description isn't part of it. `log` shows the whole stack. `submit` and `merge` act on a change and the ones below it, which must be a chain: no merges, no conflicts, and exactly one bookmark on each change.", "The repository is the one the `origin` remote points to. The token is read from `GH_TOKEN` or `GITHUB_TOKEN`, and otherwise from `gh auth token`."));
+var jjGhCommand = make31("jj gh").pipe(withSubcommands([
+  doctorCommand,
+  initCommand,
+  logCommand,
+  mergeCommand,
+  submitCommand,
+  syncCommand
+]), withHelp("Commands for publishing jj changes as GitHub pull requests", "A stack is a chain of changes, each published as one pull request on the branch its bookmark names. Each pull request targets the branch of the change below it, so it shows only that change's diff. A single change is a stack of one, and is published as an ordinary pull request.", "The stack of a change is every change connected to it through mutable changes. An empty working copy with no description isn't part of it. `log` shows the whole stack. `submit` and `merge` act on a change and the ones below it, which must be a chain: no merges, no conflicts, and exactly one bookmark on each change.", "The repository is the one the `origin` remote points to. The token is read from `GH_TOKEN` or `GITHUB_TOKEN`, and otherwise from `gh auth token`."));
 
 // src/main.ts
 runMain2(run5(jjGhCommand, { version: package_default.version }).pipe(provide3([GitLive, JjLive]), provide3(layer13({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jj-octo",
-  "version": "0.5.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": {