restore review completion and support linear JJ integration

xesrevinu · xesrevinu · commit 2759122014fe · 2026-03-16T14:03:11.000+08:00
diff --git a/.changeset/restore-review-completion-and-jj-linear-history.md b/.changeset/restore-review-completion-and-jj-linear-history.md
@@ -0,0 +1,5 @@
+---
+"@effect-x/lalph": patch
+---
+
+add project review-completion setting so successful loops can automatically move issues from review to done, support local JJ target branches such as `main` for local-only linear integration, and serialize project integration so concurrent JJ tasks merge back one at a time.
diff --git a/README.md b/README.md
@@ -83,6 +83,10 @@ for runs, how many tasks can run concurrently, which branch to target, what git
 flow to use, whether review is enabled, and whether successful loops should
 leave issues in review or automatically move them to done.
 
+For Jujutsu commit mode, the target branch can be a local bookmark such as
+`main` for local-only linear integration, or a remote-tracking branch such as
+`origin/main` when you also want lalph to fetch and push automatically.
+
 `lalph` runs across all enabled projects in parallel; for single-project
 commands, you'll be prompted to choose an active project when needed.
 
diff --git a/src/GitFlow.test.ts b/src/GitFlow.test.ts
@@ -558,3 +558,101 @@ test("GitFlowCommit.postWork rebases jj changes onto the local bookmark for line
     "jj git push --remote origin --bookmark master",
   ])
 })
+
+test("GitFlowCommit.postWork supports local-only jj target branches without remote sync", async (t) => {
+  const { directory, repositoryDirectory } = makeJjDirectory()
+  t.after(() => {
+    rmSync(directory, { force: true, recursive: true })
+  })
+
+  const project = new Project({
+    checkoutMode: "in-place",
+    concurrency: 1,
+    enabled: true,
+    gitFlow: "commit",
+    id: projectId,
+    reviewAgent: false,
+    reviewCompletion: "manual",
+    targetBranch: Option.some("master"),
+  })
+
+  const commands: Array<string> = []
+  const worktree = {
+    directory: repositoryDirectory,
+    exec: (
+      template: TemplateStringsArray,
+      ...args: Array<string | number | boolean>
+    ) =>
+      Effect.sync(() => {
+        commands.push(String.raw({ raw: template }, ...args))
+        return 0
+      }),
+    repository: {
+      kind: "jj" as const,
+      root: repositoryDirectory,
+    },
+  } as unknown as Worktree["Service"]
+
+  await withCurrentDirectory(repositoryDirectory, () =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        const gitFlow = yield* GitFlow
+        yield* gitFlow.postWork({
+          issueId: "AUT-71",
+          targetBranch: "master",
+          worktree,
+        })
+      }).pipe(
+        Effect.provide(GitFlowCommit),
+        Effect.provideService(CurrentProjectId, CurrentProjectId.of(projectId)),
+        Effect.provideService(
+          CurrentWorkerState,
+          CurrentWorkerState.of({
+            output: Atom.make(Chunk.empty<string>()),
+            state: Atom.make(
+              WorkerState.initial({
+                id: 1,
+                projectId,
+              }),
+            ),
+          }),
+        ),
+        Effect.provideService(Settings, settingsWithProjects(project)),
+        Effect.provideService(
+          Prd,
+          Prd.of({
+            findById: () => Effect.succeed(null),
+            flagUnmergable: () => Effect.void,
+            maybeRevertIssue: () => Effect.void,
+            path: join(repositoryDirectory, ".lalph", "prd.yml"),
+            revertUpdatedIssues: Effect.void,
+            setAutoMerge: () => Effect.void,
+            setChosenIssueId: () => Effect.void,
+          }),
+        ),
+        Effect.provideService(
+          IssueSource,
+          IssueSource.of({
+            cancelIssue: () => Effect.void,
+            cliAgentPresetInfo: () => Effect.void,
+            createIssue: () => Effect.die("unused"),
+            ensureInProgress: () => Effect.void,
+            info: () => Effect.void,
+            issueCliAgentPreset: () => Effect.succeed(Option.none()),
+            issues: () => Effect.succeed([]),
+            reset: Effect.void,
+            settings: () => Effect.void,
+            updateCliAgentPreset: () => Effect.die("unused"),
+            updateIssue: () => Effect.void,
+          }),
+        ),
+        Effect.provide(PlatformServices),
+      ),
+    ),
+  )
+
+  assert.deepEqual(commands, [
+    "jj rebase --branch @ --onto master",
+    "jj bookmark set master --revision @",
+  ])
+})
diff --git a/src/GitFlow.ts b/src/GitFlow.ts
@@ -10,6 +10,7 @@ import {
 } from "effect"
 import type { PlatformError } from "effect/PlatformError"
 import { Atom, AtomRegistry } from "effect/unstable/reactivity"
+import type { ChildProcessSpawner } from "effect/unstable/process"
 import {
   HookCommandFailedError,
   Hooks,
@@ -21,10 +22,11 @@ import { CurrentProjectId } from "./Settings.ts"
 import { projectById } from "./Projects.ts"
 import type { Worktree } from "./Worktree.ts"
 import { CurrentWorkerState } from "./Workers.ts"
-import { parseBranch } from "./shared/git.ts"
 import {
   getCurrentRepository,
+  resolveTargetBranch,
   targetBranchToJjBookmark,
+  targetBranchToJjRevision,
   type VcsKind,
 } from "./shared/vcs.ts"
 
@@ -52,7 +54,10 @@ export class GitFlow extends ServiceMap.Service<
     }) => Effect.Effect<
       void,
       IssueSourceError | PlatformError | GitFlowError,
-      Prd | IssueSource | CurrentProjectId
+      | Prd
+      | IssueSource
+      | CurrentProjectId
+      | ChildProcessSpawner.ChildProcessSpawner
     >
     readonly autoMerge: (options: {
       readonly targetBranch: string | undefined
@@ -320,10 +325,15 @@ But you **do not** need to push your changes or switch workspaces, and you shoul
         }
         const prd = yield* Prd
 
-        const parsed = parseBranch(targetBranch)
+        const parsed = yield* resolveTargetBranch({
+          repository: worktree.repository,
+          targetBranch,
+        })
 
         if (worktree.repository.kind === "git") {
-          yield* worktree.exec`git fetch ${parsed.remote}`
+          if (Option.isSome(parsed.remote)) {
+            yield* worktree.exec`git fetch ${parsed.remote.value}`
+          }
           yield* worktree.exec`git restore --worktree .`
 
           const rebaseResult =
@@ -335,25 +345,29 @@ But you **do not** need to push your changes or switch workspaces, and you shoul
             })
           }
 
-          const pushResult =
-            yield* worktree.exec`git push ${parsed.remote} ${`HEAD:${parsed.branch}`}`
-          if (pushResult !== 0) {
-            yield* prd.flagUnmergable({ issueId })
-            return yield* new GitFlowError({
-              message: `Failed to push changes to ${parsed.branchWithRemote}. Aborting task.`,
-            })
+          if (Option.isSome(parsed.remote)) {
+            const pushResult =
+              yield* worktree.exec`git push ${parsed.remote.value} ${`HEAD:${parsed.branch}`}`
+            if (pushResult !== 0) {
+              yield* prd.flagUnmergable({ issueId })
+              return yield* new GitFlowError({
+                message: `Failed to push changes to ${parsed.branchWithRemote}. Aborting task.`,
+              })
+            }
           }
           return
         }
 
-        yield* worktree.exec`jj git fetch --remote ${parsed.remote} --branch ${parsed.branch}`
-        yield* worktree.exec`jj bookmark track ${parsed.branch} --remote ${parsed.remote}`
+        if (Option.isSome(parsed.remote)) {
+          yield* worktree.exec`jj git fetch --remote ${parsed.remote.value} --branch ${parsed.branch}`
+          yield* worktree.exec`jj bookmark track ${parsed.branch} --remote ${parsed.remote.value}`
+        }
         const rebaseResult =
-          yield* worktree.exec`jj rebase --branch ${"@"} --onto ${targetBranchToJjBookmark(targetBranch)}`
+          yield* worktree.exec`jj rebase --branch ${"@"} --onto ${targetBranchToJjBookmark(parsed)}`
         if (rebaseResult !== 0) {
           yield* prd.flagUnmergable({ issueId })
           return yield* new GitFlowError({
-            message: `Failed to rebase onto ${targetBranchToJjBookmark(targetBranch)}. Aborting task.`,
+            message: `Failed to rebase onto ${targetBranchToJjBookmark(parsed)}. Aborting task.`,
           })
         }
         const setBookmarkResult =
@@ -365,13 +379,15 @@ But you **do not** need to push your changes or switch workspaces, and you shoul
           })
         }
 
-        const pushResult =
-          yield* worktree.exec`jj git push --remote ${parsed.remote} --bookmark ${parsed.branch}`
-        if (pushResult !== 0) {
-          yield* prd.flagUnmergable({ issueId })
-          return yield* new GitFlowError({
-            message: `Failed to push jj bookmark ${parsed.branch}@${parsed.remote}. Aborting task.`,
-          })
+        if (Option.isSome(parsed.remote)) {
+          const pushResult =
+            yield* worktree.exec`jj git push --remote ${parsed.remote.value} --bookmark ${parsed.branch}`
+          if (pushResult !== 0) {
+            yield* prd.flagUnmergable({ issueId })
+            return yield* new GitFlowError({
+              message: `Failed to push jj bookmark ${targetBranchToJjRevision(parsed)}. Aborting task.`,
+            })
+          }
         }
       }),
       autoMerge: Effect.fnUntraced(function* (options) {
diff --git a/src/Projects.ts b/src/Projects.ts
@@ -103,7 +103,8 @@ export const addOrUpdateProject = Effect.fnUntraced(function* (
   })
   const targetBranch = pipe(
     yield* Prompt.text({
-      message: "Target branch (leave empty to use HEAD)",
+      message:
+        "Target branch (e.g. main or origin/main; leave empty to use HEAD)",
       default: existing
         ? Option.getOrElse(existing.targetBranch, () => "")
         : "",
diff --git a/src/Worktree.test.ts b/src/Worktree.test.ts
@@ -45,6 +45,10 @@ const seedGitCommit = (directory: string) => {
     cwd: directory,
     stdio: "pipe",
   })
+  execFileSync("git", ["config", "commit.gpgsign", "false"], {
+    cwd: directory,
+    stdio: "pipe",
+  })
   execFileSync("git", ["commit", "--allow-empty", "-m", "init"], {
     cwd: directory,
     stdio: "pipe",
@@ -73,6 +77,10 @@ const makeJjDirectory = (branches: ReadonlyArray<string> = []) => {
     cwd: seedDirectory,
     stdio: "pipe",
   })
+  execFileSync("git", ["config", "commit.gpgsign", "false"], {
+    cwd: seedDirectory,
+    stdio: "pipe",
+  })
 
   writeFileSync(join(seedDirectory, "README.md"), "init\n")
   execFileSync("git", ["add", "README.md"], {
@@ -555,6 +563,85 @@ test(
   },
 )
 
+test(
+  "Worktree.layer creates jj workspaces from a local target bookmark without fetching a remote",
+  { concurrency: false },
+  async (t) => {
+    const { directory, repositoryDirectory } = makeJjDirectory(["release"])
+    t.after(() => {
+      rmSync(directory, { force: true, recursive: true })
+    })
+
+    execFileSync(
+      "jj",
+      ["bookmark", "set", "release", "--revision", "release@origin"],
+      {
+        cwd: repositoryDirectory,
+        stdio: "pipe",
+      },
+    )
+
+    mkdirSync(join(repositoryDirectory, ".lalph"), { recursive: true })
+    writeFileSync(
+      join(repositoryDirectory, ".lalph", "hooks.yml"),
+      `hooks:
+  post-create:
+    capture: >-
+      printf '%s:%s\\n' '{{ workspace }}' "$LALPH_TARGET_BRANCH" >> .hook-log
+`,
+    )
+
+    const jjProjectId = Schema.decodeUnknownSync(ProjectId)("AUT-79")
+    const project = new Project({
+      checkoutMode: "worktree",
+      concurrency: 1,
+      enabled: true,
+      gitFlow: "commit",
+      id: jjProjectId,
+      reviewAgent: false,
+      reviewCompletion: "manual",
+      targetBranch: Option.some("release"),
+    })
+
+    const result = await withCurrentDirectory(repositoryDirectory, () =>
+      Effect.runPromise(
+        Effect.scoped(
+          Effect.gen(function* () {
+            const worktree = yield* Worktree
+            const parentDescription = execFileSync(
+              "jj",
+              ["log", "-r", "@-", "--no-graph", "-T", 'description ++ "\\n"'],
+              {
+                cwd: worktree.directory,
+                encoding: "utf8",
+                stdio: "pipe",
+              },
+            )
+            return {
+              hookLog: readFileSync(
+                join(worktree.directory, ".hook-log"),
+                "utf8",
+              ),
+              parentDescription,
+            } as const
+          }).pipe(
+            Effect.provide(Worktree.layer),
+            Effect.provideService(
+              CurrentProjectId,
+              CurrentProjectId.of(jjProjectId),
+            ),
+            Effect.provideService(Settings, settingsWithProjects(project)),
+            Effect.provide(PlatformServices),
+          ),
+        ),
+      ),
+    )
+
+    assert.equal(result.hookLog.endsWith(":release\n"), true)
+    assert.equal(result.parentDescription.trimEnd(), "release")
+  },
+)
+
 test(
   "Worktree.layerWorktree creates jj workspaces even when the project uses in-place mode",
   { concurrency: false },
diff --git a/src/Worktree.ts b/src/Worktree.ts
@@ -26,7 +26,6 @@ import {
 import { projectById } from "./Projects.ts"
 import { CurrentProjectId } from "./Settings.ts"
 import { constWorkerMaxOutputChunks, CurrentWorkerState } from "./Workers.ts"
-import { parseBranch } from "./shared/git.ts"
 import {
   resolveLalphDirectory,
   syncLalphDirectory,
@@ -37,6 +36,7 @@ import {
   getCurrentRepository,
   getGithubRepository,
   makeJjWorkspaceName,
+  resolveTargetBranch,
   targetBranchToJjRevision,
 } from "./shared/vcs.ts"
 
@@ -237,18 +237,25 @@ export const setupWorktree = Effect.fnUntraced(function* (options: {
   const targetBranch = yield* getTargetBranch
 
   if (Option.isSome(targetBranch)) {
-    const parsed = parseBranch(targetBranch.value)
+    const parsed = yield* resolveTargetBranch({
+      repository: options.repository,
+      targetBranch: targetBranch.value,
+    })
 
     if (options.repository.kind === "git") {
-      yield* options.exec`git fetch ${parsed.remote}`
+      if (Option.isSome(parsed.remote)) {
+        yield* options.exec`git fetch ${parsed.remote.value}`
+      }
       const code = yield* options.exec`git checkout ${parsed.branchWithRemote}`
-      if (code !== 0) {
+      if (code !== 0 && Option.isSome(parsed.remote)) {
         yield* options.exec`git checkout -b ${parsed.branch}`
-        yield* options.exec`git push -u ${parsed.remote} ${parsed.branch}`
+        yield* options.exec`git push -u ${parsed.remote.value} ${parsed.branch}`
       }
     } else {
-      yield* options.exec`jj git fetch --remote ${parsed.remote} --branch ${parsed.branch}`
-      yield* options.exec`jj new ${targetBranchToJjRevision(targetBranch.value)}`
+      if (Option.isSome(parsed.remote)) {
+        yield* options.exec`jj git fetch --remote ${parsed.remote.value} --branch ${parsed.branch}`
+      }
+      yield* options.exec`jj new ${targetBranchToJjRevision(parsed)}`
     }
   }
 
diff --git a/src/commands/plan.ts b/src/commands/plan.ts
diff --git a/src/commands/root.ts b/src/commands/root.ts
diff --git a/src/shared/vcs.ts b/src/shared/vcs.ts

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@effect-x/lalph": patch
 +---
++
 +add project review-completion setting so successful loops can automatically move issues from review to done, support local JJ target branches such as `main` for local-only linear integration, and serialize project integration so concurrent JJ tasks merge back one at a time.