jj-octo 0.7.1 → 0.8.0

package/dist/jj-octo.js

@@ -1410,6 +1410,7 @@ var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
 var map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
 var toArray = (self) => isNone2(self) ? [] : [self.value];
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => isNone2(self) ? none2() : predicate(self.value) ? some2(self.value) : none2());
 var exists = /* @__PURE__ */ dual(2, (self, refinement) => isNone2(self) ? false : refinement(self.value));
 
 // node_modules/effect/dist/Context.js
@@ -3380,6 +3381,14 @@ var catchCauseFilter = /* @__PURE__ */ dual(3, (self, filter, f) => catchCause(s
 }));
 var catch_ = /* @__PURE__ */ dual(2, (self, f) => catchCauseFilter(self, findError, (e) => f(e)));
 var tapCause = /* @__PURE__ */ dual(2, (self, f) => catchCause(self, (cause) => andThen(f(cause), failCause(cause))));
+var tapCauseFilter = /* @__PURE__ */ dual(3, (self, filter, f) => catchCause(self, (cause) => {
+  const result = filter(cause);
+  if (isFailure2(result)) {
+    return failCause(cause);
+  }
+  return andThen(f(result.success, cause), failCause(cause));
+}));
+var tapError = /* @__PURE__ */ dual(2, (self, f) => tapCauseFilter(self, findError, (e) => f(e)));
 var catchIf = /* @__PURE__ */ dual((args) => isEffect(args[0]), (self, predicate, f, orElse) => catchCause(self, (cause) => {
   const error = findError(cause);
   if (isFailure2(error))
@@ -4998,6 +5007,7 @@ var catchCause2 = catchCause;
 var catchFilter2 = catchFilter;
 var mapError3 = mapError2;
 var orDie2 = orDie;
+var tapError2 = tapError;
 var tapCause2 = tapCause;
 var ignore2 = ignore;
 var orElseSucceed2 = orElseSucceed;
@@ -10937,6 +10947,9 @@ function decodeUnknownEffect(schema, options) {
   const parser = run2(schema.ast);
   return options === undefined ? parser : (input, overrideOptions) => parser(input, mergeParseOptions(options, overrideOptions));
 }
+function decodeUnknownOption(schema, options) {
+  return asOption(decodeUnknownEffect(schema, options));
+}
 var mergeParseOptions = (options, overrideOptions) => overrideOptions ? {
   ...options,
   ...overrideOptions
@@ -10975,6 +10988,17 @@ function runWithCompiler(compiler, ast) {
 function asExit(parser) {
   return (input, options) => runSyncExit2(parser(input, options));
 }
+function asOption(parser) {
+  const parserExit = asExit(parser);
+  return (input, options) => {
+    const exit = parserExit(input, options);
+    if (isSuccess3(exit)) {
+      return some2(exit.value);
+    }
+    getSchemaIssueOrThrow(exit.cause, "Option adapter can only return none for schema issues");
+    return none2();
+  };
+}
 function runSync3(effect, message) {
   const exit = runSyncExit2(effect);
   if (isSuccess3(exit)) {
@@ -11304,6 +11328,7 @@ function decodeUnknownEffect2(schema, options) {
   };
 }
 var decodeEffect2 = decodeUnknownEffect2;
+var decodeUnknownOption2 = decodeUnknownOption;
 var make25 = make24;
 function isSchema(u) {
   return hasProperty(u, TypeId29) && u[TypeId29] === TypeId29;
@@ -18239,7 +18264,7 @@ var layer14 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch)
 // package.json
 var package_default = {
   name: "jj-octo",
-  version: "0.7.1",
+  version: "0.8.0",
   description: "A jj subcommand for GitHub that supports stacked pull requests and works in Claude Code cloud sessions",
   license: "MIT",
   repository: {
@@ -18449,6 +18474,10 @@ var anyOf = (revsets) => ["none()", ...revsets].join(" | ");
 var bookmarkRevset = (bookmark) => `bookmarks(exact:"${bookmark}")`;
 var lines2 = (output) => output.split(`
 `).filter((line) => line !== "");
+var parseDescription = (json) => {
+  const parsed = JSON.parse(json);
+  return typeof parsed === "string" ? parsed : "";
+};
 var readLog = (revset, template) => gen2(function* () {
   const jj = yield* Jj;
   return yield* jj.read(["log", "--no-graph", "--reversed", "-r", revset, "-T", template]);
@@ -18496,8 +18525,7 @@ var loggedChanges = (revset) => logLines(revset, CHANGE).pipe(map7((logged) => l
     bookmarks = "",
     json = '""'
   ] = line.split("\t");
-  const parsed = JSON.parse(json);
-  const description = typeof parsed === "string" ? parsed : "";
+  const description = parseDescription(json);
   return {
     bookmarks: bookmarks === "" ? [] : bookmarks.split(" "),
     changeId,
@@ -18916,6 +18944,64 @@ var log2 = (revision) => gen2(function* () {
 var logCommand = make31("log", { revision: revisionFlag("A change of the stack to show") }, ({ revision }) => asUserError(log2(revision).pipe(provide3(GitHubFromOrigin))).pipe(flatMap4((printed) => log(printed.join(`
 `))))).pipe(withHelp("Show changes and their pull requests", "Prints one line per change, top first: its bookmark, its pull request with whether that is a draft or ready for review, and whether the change is pushed, changed since the push, or not pushed.", "Fails if the changes aren't a chain, if one has conflicts, or if one doesn't have exactly one bookmark. `submit` makes the same check before it changes anything.", "Changes nothing, locally or on GitHub."));
 
+// src/clients/pr-descriptions.ts
+class PrDescriptions extends Service()("jj-octo/PrDescriptions") {
+}
+var StoredRecord = Struct({
+  bookmark: String4,
+  commit: String4,
+  description: String4
+});
+var decode2 = decodeUnknownOption2(fromJsonString2(StoredRecord));
+var RECORD = /^\d+$/u;
+var PARTIAL = /^\d+\.[\da-f-]+\.partial$/u;
+var STOPPED_AFTER_MS = 60 * 60 * 1000;
+var warn = (action) => (error2) => error(`couldn't ${action} the agreed pull request descriptions: ${error2.message}`);
+var prDescriptionsLayer = effect(PrDescriptions, gen2(function* () {
+  const fs = yield* FileSystem;
+  const jj = yield* Jj;
+  const path = yield* Path;
+  const directory = yield* cached2(gen2(function* () {
+    const dotJj = path.join((yield* jj.read(["workspace", "root"])).trim(), ".jj");
+    const repository = path.join(dotJj, "repo");
+    const shared = (yield* fs.stat(repository)).type === "File" ? path.resolve(dotJj, (yield* fs.readFileString(repository)).trim()) : repository;
+    return path.join(shared, "jj-octo", "pr-descriptions");
+  }));
+  const recordOf = (file) => fs.readFileString(file).pipe(map7(decode2), orElseSucceed2(() => none2()));
+  const remove = (file, name) => fs.remove(file, { force: true }).pipe(catch_2(warn(`prune ${name} in`)));
+  return {
+    prune: (bookmarks) => gen2(function* () {
+      const records = yield* directory;
+      const names = (yield* fs.exists(records)) ? yield* fs.readDirectory(records) : [];
+      const recorded = names.filter((name) => RECORD.test(name));
+      const left = recorded.length === 0 ? [] : yield* bookmarks;
+      for (const name of recorded) {
+        const file = path.join(records, name);
+        const record = yield* recordOf(file);
+        if (isNone2(record) || !left.includes(record.value.bookmark)) {
+          yield* remove(file, name);
+        }
+      }
+      const now = Date.now();
+      for (const name of names.filter((file) => PARTIAL.test(file))) {
+        const file = path.join(records, name);
+        const modified = yield* fs.stat(file).pipe(map7(({ mtime }) => getOrElse(mtime, () => new Date(0)).getTime()), orElseSucceed2(() => now));
+        if (now - modified > STOPPED_AFTER_MS) {
+          yield* remove(file, name);
+        }
+      }
+    }).pipe(catch_2(warn("prune"))),
+    read: (pullRequest, bookmark) => directory.pipe(flatMap4((records) => recordOf(path.join(records, String(pullRequest)))), map7(filter((record) => record.bookmark === bookmark)), orElseSucceed2(() => none2())),
+    write: ({ bookmark, commit, description, pullRequest }) => gen2(function* () {
+      const records = yield* directory;
+      yield* fs.makeDirectory(records, { recursive: true });
+      const record = path.join(records, String(pullRequest));
+      const partial = `${record}.${crypto.randomUUID()}.partial`;
+      yield* fs.writeFileString(partial, JSON.stringify({ bookmark, commit, description })).pipe(andThen2(fs.rename(partial, record)), tapError2(() => fs.remove(partial, { force: true }).pipe(ignore2)));
+    }).pipe(catch_2(warn("record")))
+  };
+}));
+
 // src/cli/gh/stack/plan.ts
 var basesFor = (branches, trunk) => [
   trunk,
@@ -18960,44 +19046,93 @@ var normalizedDescription = (description, { ignoreClaudeCodeFooter }) => {
 `);
   return descriptionFrom(titleAndBody(ignoreClaudeCodeFooter ? text.replace(claudeCodeFooter, "") : text));
 };
+var agreedDescription = ({
+  isOwnEarlier,
+  onGitHub,
+  pushed,
+  recorded
+}) => getOrElse(recorded, () => isOwnEarlier ? onGitHub : pushed);
 var descriptionSyncFor = ({
+  agreed,
   local,
-  onGitHub,
-  pushed
+  onGitHub
 }) => {
   if (local === onGitHub) {
     return { _tag: "InSync" };
   }
-  if (local === pushed) {
+  if (local === agreed) {
     return { _tag: "TakeGitHub" };
   }
-  return onGitHub === pushed ? { _tag: "SendLocal" } : { _tag: "Merge" };
+  return onGitHub === agreed ? { _tag: "SendLocal" } : { _tag: "Merge" };
 };
 
 // src/cli/gh/stack/descriptions.ts
 class DescriptionConflict extends TaggedError2("DescriptionConflict") {
 }
+var kept = (text) => ({ send: false, text });
+var sent = (text) => ({ send: true, text });
 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 : ""];
+  return [commit, parseDescription(json)];
 }))));
-var syncDescription = ({ bookmark, description }, pullRequest, { ignoreClaudeCodeFooter, overwriteDescriptions, pushedDescription }) => gen2(function* () {
+var ownHistory = (bookmark, changeId) => gen2(function* () {
+  const jj = yield* Jj;
+  const output = yield* jj.read([
+    "evolog",
+    "--no-graph",
+    "-r",
+    bookmarkRevset(bookmark),
+    "-T",
+    String.raw`commit.change_id() ++ "\t" ++ commit.commit_id() ++ "\t" ++ predecessors.map(|p| p.commit_id()).join(",") ++ "\t" ++ if(operation, operation.description()) ++ "\t" ++ commit.description().escape_json() ++ "\n"`
+  ]);
+  return lines2(output).flatMap((line) => {
+    const [change = "", commit = "", predecessors = "", operation = "", json = '""'] = line.split("\t");
+    const isImported = operation.startsWith("fetch from git") || operation.startsWith("import git");
+    return change === changeId ? [
+      {
+        commit,
+        description: parseDescription(json),
+        isImported,
+        predecessors: predecessors === "" ? [] : predecessors.split(",")
+      }
+    ] : [];
+  });
+});
+var isDescribedHereFrom = (history, commit) => {
+  const since = history.findIndex((entry) => entry.commit === commit);
+  const descriptions = new Map(history.map((entry) => [entry.commit, entry.description]));
+  return since !== -1 && history.slice(0, since).every(({ description, isImported, predecessors }) => !isImported || predecessors.some((each) => descriptions.get(each) === description));
+};
+var syncDescription = ({ bookmark, changeId, description }, pullRequest, {
+  ignoreClaudeCodeFooter,
+  overwriteDescriptions,
+  pushedCommit,
+  pushedDescription
+}) => gen2(function* () {
   const git = yield* Git;
   const jj = yield* Jj;
+  const records = yield* PrDescriptions;
   const describe = (text) => jj.run(["describe", "-r", bookmarkRevset(bookmark), "-m", text]);
-  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* () {
+  const footer = { ignoreClaudeCodeFooter };
+  const normalized = (text) => normalizedDescription(text, footer);
+  const local = normalized(description);
+  const onGitHub = normalized(descriptionFrom(pullRequest));
+  const pushed = normalized(pushedDescription);
+  const record = yield* records.read(pullRequest.number, bookmark);
+  const history = local === onGitHub || isNone2(record) && onGitHub === pushed ? [] : yield* ownHistory(bookmark, changeId);
+  const age = (commit) => history.findIndex((entry) => entry.commit === commit);
+  const pushedAge = age(pushedCommit);
+  const isPushedAgreedSince = (commit) => onGitHub === pushed && pushedAge !== -1 && pushedAge < age(commit);
+  const recorded = record.pipe(filter(({ commit }) => isDescribedHereFrom(history, commit) && !isPushedAgreedSince(commit)), map(({ description: text }) => normalized(text)));
+  const isOwnEarlier = onGitHub !== pushed && history.some((entry) => normalized(entry.description) === onGitHub);
+  const agreed = agreedDescription({ isOwnEarlier, onGitHub, pushed, recorded });
+  return yield* value4(descriptionSyncFor({ agreed, local, onGitHub })).pipe(tag3("InSync", () => succeed6(kept(local))), tag3("TakeGitHub", () => describe(onGitHub).pipe(andThen2(error(`took the description of #${pullRequest.number} from GitHub`)), as2(kept(onGitHub)))), tag3("SendLocal", () => succeed6(sent(local))), tag3("Merge", () => gen2(function* () {
     if (overwriteDescriptions) {
-      return some2(local);
+      return sent(local);
     }
-    const merged = yield* git.mergeText({ base: pushed, local, remote: onGitHub });
+    const merged = yield* git.mergeText({ base: agreed, local, remote: onGitHub });
     if (merged.conflicted) {
       return yield* new DescriptionConflict({
         message: [
@@ -19011,7 +19146,7 @@ var syncDescription = ({ bookmark, description }, pullRequest, { ignoreClaudeCod
       });
     }
     yield* describe(merged.text);
-    return some2(merged.text);
+    return sent(merged.text);
   })), exhaustive2);
 });
 
@@ -19199,6 +19334,8 @@ var reconcile = ({
   }
   const onStacks = new Set(scope === "every stack" ? before.map(({ name }) => name) : scope.bookmarks);
   yield* forget((yield* bookmarksAt("::trunk()")).filter((name) => onStacks.has(name)));
+  const records = yield* PrDescriptions;
+  yield* records.prune(provideService2(bookmarksAt("all()"), Jj, jj));
   if (notCombined.length > 0) {
     yield* new NotCombined({
       message: [
@@ -19304,6 +19441,7 @@ var register = (remaining, pullRequests) => gen2(function* () {
 var publish = (stack, { draft, overwriteDescriptions, trunk }) => gen2(function* () {
   const github = yield* GitHub;
   const jj = yield* Jj;
+  const records = yield* PrDescriptions;
   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" });
@@ -19311,19 +19449,25 @@ var publish = (stack, { draft, overwriteDescriptions, trunk }) => gen2(function*
   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;
+  for (const { base, change, pullRequest } of found) {
+    const pushed = targets.get(change.bookmark)?.origin;
+    const options = {
+      ignoreClaudeCodeFooter,
+      overwriteDescriptions,
+      pushedCommit: pushed,
+      pushedDescription: (pushed === undefined ? undefined : pushedDescriptions.get(pushed)) ?? ""
+    };
     changes.push({
-      ...entry,
-      description: isNone2(entry.pullRequest) ? none2() : yield* syncDescription(entry.change, entry.pullRequest.value, {
-        ignoreClaudeCodeFooter,
-        overwriteDescriptions,
-        pushedDescription: (pushed === undefined ? undefined : pushedDescriptions.get(pushed)) ?? ""
+      base,
+      change,
+      open: isNone2(pullRequest) ? none2() : some2({
+        pullRequest: pullRequest.value,
+        synced: yield* syncDescription(change, pullRequest.value, options)
       })
     });
   }
-  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 moving = changes.flatMap(({ base, open }) => isSome2(open) && open.value.pullRequest.base !== base ? [open.value.pullRequest] : []);
+  const wanted = changes.map(({ open }) => map(open, ({ pullRequest }) => pullRequest.number));
   const existing = yield* stackContaining(wanted.flatMap((number) => toArray(number)));
   const dissolve = mustDissolve(existing, wanted, moving.length > 0);
   if (dissolve && isSome2(existing)) {
@@ -19342,9 +19486,16 @@ var publish = (stack, { draft, overwriteDescriptions, trunk }) => gen2(function*
     "push",
     ...bookmarks.flatMap((bookmark) => ["--bookmark", `exact:${bookmark}`])
   ]);
+  const pushedTargets = yield* bookmarkTargets;
+  const record = (bookmark, description, pullRequest) => records.write({
+    bookmark,
+    commit: pushedTargets.get(bookmark)?.local ?? "",
+    description,
+    pullRequest
+  });
   const numbers = [];
-  for (const { base, change, description, pullRequest } of changes) {
-    if (isNone2(pullRequest)) {
+  for (const { base, change, open } of changes) {
+    if (isNone2(open)) {
       const created = yield* github.createPullRequest({
         ...titleAndBody(change.description),
         base,
@@ -19352,16 +19503,21 @@ var publish = (stack, { draft, overwriteDescriptions, trunk }) => gen2(function*
         head: change.bookmark
       });
       yield* error(`opened #${created} for ${change.bookmark}`);
+      yield* record(change.bookmark, change.description, created);
       numbers.push(created);
     } else {
-      const { number } = pullRequest.value;
+      const {
+        pullRequest: { number },
+        synced: { send, text }
+      } = open.value;
       if (moved.has(number) && base !== trunk) {
         yield* github.setBase(number, base);
       }
-      if (isSome2(description)) {
-        yield* github.setDescription(number, titleAndBody(description.value));
+      if (send) {
+        yield* github.setDescription(number, titleAndBody(text));
         yield* error(`updated the description of #${number}`);
       }
+      yield* record(change.bookmark, text, number);
       numbers.push(number);
     }
   }
@@ -19472,7 +19628,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.", "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."));
+}, ({ 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. That holds for a local edit pushed with `jj git push` too, since submit records the description that both sides last agreed on in `jj-octo/pr-descriptions` under the repository's `.jj/repo`, in the main workspace. 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([
@@ -19485,6 +19641,6 @@ var jjGhCommand = make31("jj gh").pipe(withSubcommands([
 ]), 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({
+runMain2(run5(jjGhCommand, { version: package_default.version }).pipe(provide3([GitLive, provideMerge(prDescriptionsLayer, JjLive)]), provide3(layer13({
   builtIns: [Help, Version, Wizard, LogLevel]
 })), provide3([layer12, layer14])));

package/package.json

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