jj-octo 0.4.0 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # jj-octo
 
-A [jj](https://github.com/jj-vcs/jj) subcommand for working with GitHub that supports stacking.
+A [jj](https://github.com/jj-vcs/jj) subcommand for GitHub that supports stacked pull requests and works in Claude Code cloud sessions.
 
 > [!WARNING]
 > `jj-octo` is in early development, and its commands may change. So far it is largely vibe coded.
@@ -28,31 +28,35 @@ 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. It takes its token from `GH_TOKEN` or `GITHUB_TOKEN`, and otherwise from `gh auth token`. It sends requests through the proxy that `HTTPS_PROXY` names, and trusts the certificate authorities in `NODE_EXTRA_CA_CERTS` as well as Bun's own.
+`jj-octo` reads the repository from the `origin` remote.
 
-## In a Claude Code cloud session
+By default, it reads its token from `GH_TOKEN` or `GITHUB_TOKEN`, and otherwise runs `gh auth token`.
 
-In a [Claude Code](https://claude.com/claude-code) cloud session, a proxy carries all traffic to GitHub. It allows REST calls only for the session's repositories, and blocks GraphQL. That's why `jj-octo` uses only GitHub's REST API, while `gh pr` and other tools that depend on GraphQL fail there.
+With `jj-octo.github-auth` set to `git-proxy`, it sends a placeholder token instead. It sends requests through git's proxy for github.com, and trusts git's certificate authorities for it in place of Bun's own. [In a self-hosted environment](#in-a-self-hosted-environment) describes when to use it.
 
-mise can't read this repository's releases there, since it reads them through the GitHub API. Install the npm package instead:
+## In Claude Code cloud sessions
 
-```toml
-[tools]
-bun = "A.B.C"
+A Claude Code [cloud session](https://code.claude.com/docs/en/claude-code-on-the-web) runs in an Anthropic-hosted environment, or in your organization's self-hosted environment. Each needs its own setup.
+
+The session's GitHub proxy can append a "Generated by Claude Code" footer to each pull request body that it creates or edits. `jj gh submit` would read the footer as an edit made on GitHub, and write it into the change. To have `submit` leave the footer out when it compares a pull request's body with its change's description, set:
 
-[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
 ```
+jj config set --repo jj-octo.ignore-claude-code-footer true
+```
+
+### In an Anthropic-hosted environment
+
+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.
 
-The session sets `HTTPS_PROXY`, `NODE_EXTRA_CA_CERTS` and a placeholder `GH_TOKEN`. Its proxy replaces the placeholder with real credentials. So `jj-octo` works there with its default settings.
+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 Claude Code self-hosted environment
+### In a self-hosted environment
 
-A self-hosted runner started with `--use-anthropic-git-proxy` sends git through Anthropic's git proxy, which adds the session user's credentials. The sandbox then holds no GitHub token, and only git's config names the proxy. There, have `jj-octo` use the same proxy:
+A [self-hosted runner](https://code.claude.com/docs/en/self-hosted-environments-deploy#use-the-anthropic-git-proxy) started with `--use-anthropic-git-proxy` sends git through the Anthropic git proxy. That proxy adds the GitHub credentials of the session's creator. The session then holds no GitHub token, and only git's config names the proxy. There, have `jj-octo` use the same proxy:
 
 ```
 jj config set --repo jj-octo.github-auth git-proxy

package/dist/jj-octo.js

@@ -18239,8 +18239,8 @@ var layer14 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch)
 // package.json
 var package_default = {
   name: "jj-octo",
-  version: "0.4.0",
-  description: "A jj subcommand for working with GitHub that supports stacking",
+  version: "0.6.0",
+  description: "A jj subcommand for GitHub that supports stacked pull requests and works in Claude Code cloud sessions",
   license: "MIT",
   repository: {
     type: "git",
@@ -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") {
@@ -18497,46 +18551,16 @@ 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\``
+      message: `trunk() isn't ${branch}@origin, GitHub's default branch; run \`jj-octo 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)]);
-    }
-  }
-});
+// 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"]);
@@ -18546,43 +18570,123 @@ var defaultBranch = gen2(function* () {
   }
   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 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 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, problems } = yield* runSteps(fixed);
+  if (problems.length > 0) {
+    yield* new NotSetUp({ message: problems.join(`
+`) });
   }
-  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`);
+  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.", "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."));
+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;
@@ -18711,8 +18815,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 +18838,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": {
@@ -18839,9 +18941,13 @@ var descriptionFrom = ({
 }) => body === "" ? title : `${title}
 
 ${body}`;
-var normalizedDescription = (description) => descriptionFrom(titleAndBody(description.replaceAll(`\r
+var claudeCodeFooter = /\n*---\n_Generated by \[Claude Code\]\(https:\/\/claude\.ai\/code[^\s)]*\)_\s*$/u;
+var normalizedDescription = (description, { ignoreClaudeCodeFooter }) => {
+  const text = description.replaceAll(`\r
 `, `
-`)));
+`);
+  return descriptionFrom(titleAndBody(ignoreClaudeCodeFooter ? text.replace(claudeCodeFooter, "") : text));
+};
 var descriptionSyncFor = ({
   local,
   onGitHub,
@@ -18859,18 +18965,22 @@ var descriptionSyncFor = ({
 // src/cli/gh/stack/descriptions.ts
 class DescriptionConflict extends TaggedError2("DescriptionConflict") {
 }
+var ignoreClaudeCodeFooterKey = "jj-octo.ignore-claude-code-footer";
+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);
   return [commit, typeof parsed === "string" ? parsed : ""];
 }))));
-var syncDescription = ({ bookmark, description }, pullRequest, { overwriteDescriptions, pushedDescription }) => gen2(function* () {
+var syncDescription = ({ bookmark, description }, pullRequest, { ignoreClaudeCodeFooter, overwriteDescriptions, pushedDescription }) => gen2(function* () {
   const git = yield* Git;
   const jj = yield* Jj;
   const describe = (text) => jj.run(["describe", "-r", bookmarkRevset(bookmark), "-m", text]);
-  const local = normalizedDescription(description);
-  const onGitHub = normalizedDescription(descriptionFrom(pullRequest));
-  const pushed = normalizedDescription(pushedDescription);
+  const local = normalizedDescription(description, { ignoreClaudeCodeFooter });
+  const onGitHub = normalizedDescription(descriptionFrom(pullRequest), {
+    ignoreClaudeCodeFooter
+  });
+  const pushed = normalizedDescription(pushedDescription, { ignoreClaudeCodeFooter });
   return yield* value4(descriptionSyncFor({ local, onGitHub, pushed })).pipe(tag3("InSync", () => succeed6(none2())), tag3("TakeGitHub", () => describe(onGitHub).pipe(andThen2(error(`took the description of #${pullRequest.number} from GitHub`)), as2(none2()))), tag3("SendLocal", () => succeed6(some2(local))), tag3("Merge", () => gen2(function* () {
     if (overwriteDescriptions) {
       return some2(local);
@@ -18920,12 +19030,14 @@ var publish = (stack, { draft, overwriteDescriptions }) => gen2(function* () {
   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)) ?? ""
       })
@@ -19135,7 +19247,7 @@ var sync4 = (known = []) => gen2(function* () {
 var syncCommand = make31("sync", {}, () => asUserError(gen2(function* () {
   yield* checkTrunk(yield* (yield* GitHub).defaultBranch);
   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") {
@@ -19205,7 +19317,14 @@ var submitCommand = make31("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."));
 
 // 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,7 +1,7 @@
 {
   "name": "jj-octo",
-  "version": "0.4.0",
-  "description": "A jj subcommand for working with GitHub that supports stacking",
+  "version": "0.6.0",
+  "description": "A jj subcommand for GitHub that supports stacked pull requests and works in Claude Code cloud sessions",
   "license": "MIT",
   "repository": {
     "type": "git",