rebase-git 0.0.2-nightly.20260928.132 → 0.0.2

package/dist/runtime.js

@@ -5,7 +5,7 @@ import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync2, readFileSync, realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir2, release } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { Deferred as Deferred3, Effect as Effect61 } from "effect";
+import { Deferred as Deferred3, Effect as Effect65 } from "effect";
 
 // src/contracts/environment-connection/environment-rpc.contract.ts
 import { Schema as Schema20 } from "effect";
@@ -575,14 +575,40 @@ var OperationScope = Schema13.Struct({
 }), OperationAction = Schema13.Literals(["continue", "skip", "abort"]), OperationKind = Schema13.Literals([
   "idle",
   "merge",
+  "squash",
   "rebase",
   "cherry-pick",
   "revert",
   "am",
   "unknown"
-]), RepositoryOperation = Schema13.Struct({
+]), PlanAction = Schema13.Literals([
+  "pick",
+  "reword",
+  "edit",
+  "squash",
+  "fixup",
+  "drop"
+]), PlanStep = Schema13.Struct({
+  commit: ObjectId,
+  action: PlanAction,
+  message: Schema13.NullOr(
+    Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(32e3))
+  )
+}), RebaseStep = Schema13.Struct({
+  commit: ObjectId,
+  action: PlanAction,
+  subject: Schema13.String,
+  done: Schema13.Boolean
+}), RepositoryOperation = Schema13.Struct({
   kind: OperationKind,
-  phase: Schema13.Literals(["idle", "conflicts", "edit", "ready", "blocked"]),
+  phase: Schema13.Literals([
+    "idle",
+    "conflicts",
+    "edit",
+    "ready",
+    "empty",
+    "blocked"
+  ]),
   revision: Schema13.String,
   branch: Schema13.NullOr(Schema13.String),
   commit: Schema13.NullOr(Schema13.String),
@@ -598,20 +624,79 @@ var OperationScope = Schema13.Struct({
       reason: Schema13.NullOr(Schema13.String)
     })
   ),
-  lock: Schema13.NullOr(Schema13.String)
+  lock: Schema13.NullOr(Schema13.String),
+  steps: Schema13.NullOr(Schema13.Array(RebaseStep))
 }), ExecuteOperation = Schema13.Struct({
   ...OperationScope.fields,
   revision: Schema13.String.check(Schema13.isPattern(/^[a-f0-9]{64}$/)),
   action: OperationAction
+}), MergeMode = Schema13.Literals([
+  "merge",
+  "ff-only",
+  "no-ff",
+  "squash"
+]), StartMerge = Schema13.TaggedStruct("Merge", {
+  source: Schema13.Struct({ ref: Schema13.NullOr(RefName), commit: ObjectId }),
+  mode: MergeMode
+}), StartRebase = Schema13.TaggedStruct("Rebase", {
+  onto: Schema13.Struct({ ref: Schema13.NullOr(RefName), commit: ObjectId }),
+  stash: Schema13.Boolean,
+  plan: Schema13.optionalKey(
+    Schema13.Array(PlanStep).check(
+      Schema13.isMinLength(1),
+      Schema13.isMaxLength(1e3)
+    )
+  )
+}), StartRevert = Schema13.TaggedStruct("Revert", {
+  commits: Schema13.Array(ObjectId).check(
+    Schema13.isMinLength(1),
+    Schema13.isMaxLength(256)
+  ),
+  commit: Schema13.Boolean
+}), CherryPickResult = Schema13.Literals(["commit", "stage"]), StartCherryPick = Schema13.TaggedStruct("CherryPick", {
+  commits: Schema13.Array(ObjectId).check(
+    Schema13.isMinLength(1),
+    Schema13.isMaxLength(1e3)
+  ),
+  mainline: Schema13.NullOr(
+    Schema13.Int.check(Schema13.isBetween({ minimum: 1, maximum: 64 }))
+  ),
+  result: CherryPickResult
+}), StartOperation = Schema13.Struct({
+  ...OperationScope.fields,
+  expectedHead: ObjectId,
+  operation: Schema13.Union([
+    StartMerge,
+    StartRebase,
+    StartRevert,
+    StartCherryPick
+  ])
+}), OperationStarted = Schema13.Struct({
+  outcome: Schema13.Literals([
+    "UpToDate",
+    "FastForwarded",
+    "Committed",
+    "Rebased",
+    "Staged",
+    "Stopped"
+  ]),
+  operation: RepositoryOperation
 }), OperationFailure = Schema13.TaggedStruct("OperationFailed", {
   reason: Schema13.Literals([
     "Stale",
     "Incompatible",
     "HookFailed",
     "GitRejected",
-    "Uncertain"
+    "Uncertain",
+    "NotFastForward",
+    "Unrelated",
+    "WouldOverwrite",
+    "Empty"
   ]),
-  detail: Schema13.String.check(Schema13.isMaxLength(2048))
+  detail: Schema13.String.check(Schema13.isMaxLength(2048)),
+  paths: Schema13.optionalKey(
+    Schema13.Array(RepositoryPath).check(Schema13.isMaxLength(100))
+  )
 }), RepositoryOperationsApi = {
   read: repositoryQuery("repositories/operations/read", {
     request: OperationScope,
@@ -621,6 +706,11 @@ var OperationScope = Schema13.Struct({
     request: ExecuteOperation,
     success: RepositoryOperation,
     failure: OperationFailure
+  }),
+  start: repositoryCommand("repositories/operations/start", {
+    request: StartOperation,
+    success: OperationStarted,
+    failure: OperationFailure
   })
 };
 
@@ -710,9 +800,22 @@ var PushDestination = Schema15.Struct({
 }), RemoteBranchUpdated = Schema15.Struct({
   destination: PushDestination,
   target: ObjectId
+}), PushTags = Schema15.Struct({
+  repositoryId: RepositoryId,
+  worktreePath: RepositoryPath,
+  remote: RemoteName,
+  tags: Schema15.Array(RefName).check(
+    Schema15.isMinLength(1),
+    Schema15.isMaxLength(100)
+  )
+}), TagsPushed = Schema15.Struct({
+  remote: RemoteName,
+  pushed: Schema15.Array(RefName),
+  upToDate: Schema15.Array(RefName)
 }), PushRejectedReason = Schema15.Literals([
   "RemoteMissing",
   "InvalidBranch",
+  "TagExists",
   "NonFastForward",
   "LeaseRejected",
   "HookDeclined",
@@ -727,6 +830,11 @@ var PushDestination = Schema15.Struct({
     request: PushBranch,
     success: RemoteBranchUpdated,
     failure: PushRejected
+  }),
+  pushTags: repositoryCommand("repositories/push/tags", {
+    request: PushTags,
+    success: TagsPushed,
+    failure: PushRejected
   })
 };
 
@@ -735,7 +843,7 @@ import { Schema as Schema17 } from "effect";
 
 // src/contracts/repository-refs/repository-refs.contract.ts
 import { Schema as Schema16 } from "effect";
-var FailureDetail = Schema16.String.check(Schema16.isMaxLength(2048)), RepositoryHead = Schema16.Struct({
+var RepositoryHead = Schema16.Struct({
   branch: Schema16.optional(RefName),
   commit: ObjectId
 }), RepositoryWorktree = Schema16.Struct({
@@ -761,7 +869,8 @@ var FailureDetail = Schema16.String.check(Schema16.isMaxLength(2048)), Repositor
   remote: RemoteName
 }), RepositoryTag = Schema16.Struct({
   name: RefName,
-  target: Schema16.optional(ObjectId)
+  target: Schema16.optional(ObjectId),
+  object: Schema16.optional(ObjectId)
 }), RepositoryRefsTruncation = Schema16.Struct({
   branches: Schema16.Boolean,
   remoteBranches: Schema16.Boolean,
@@ -822,7 +931,6 @@ var FailureDetail = Schema16.String.check(Schema16.isMaxLength(2048)), Repositor
     worktreePath: RepositoryPath
   }
 ), CheckoutRejected = Schema16.TaggedStruct("CheckoutRejected", {
-  detail: FailureDetail,
   reason: Schema16.Literals(["LocalChanges", "StashFailed"])
 }), RepositoryCheckoutFailure = Schema16.Union([
   RefMissing,
@@ -995,18 +1103,44 @@ import { Schema as Schema19 } from "effect";
 var TagScope = {
   repositoryId: RepositoryId,
   worktreePath: RepositoryPath
-}, CreateRepositoryTag = Schema19.Struct({
+}, TagMessage = Schema19.String.check(
+  Schema19.isMinLength(1),
+  Schema19.isMaxLength(65536)
+), CreateRepositoryTag = Schema19.Struct({
   ...TagScope,
   name: RefName,
-  target: ObjectId
+  target: ObjectId,
+  message: Schema19.optional(TagMessage)
 }), DeleteRepositoryTag = Schema19.Struct({
   ...TagScope,
-  name: RefName
+  name: RefName,
+  local: Schema19.optional(Schema19.Struct({ object: ObjectId })),
+  remote: Schema19.optional(
+    Schema19.Struct({ remote: RemoteName, object: ObjectId })
+  )
 }), RepositoryTagDeleted = Schema19.Struct({
+  name: RefName
+}), ReadRepositoryTag = Schema19.Struct({
+  ...TagScope,
+  name: RefName
+}), RepositoryTagAnnotation = Schema19.Struct({
   name: RefName,
-  target: ObjectId
+  object: ObjectId,
+  target: ObjectId,
+  tagger: Schema19.Struct({
+    name: Schema19.String.check(Schema19.isMaxLength(512)),
+    date: Schema19.String.check(Schema19.isMaxLength(64))
+  }),
+  message: Schema19.String.check(Schema19.isMaxLength(65536)),
+  signed: Schema19.Boolean
 }), TagRejected = Schema19.TaggedStruct("TagRejected", {
-  reason: Schema19.Literals(["InvalidName", "Exists"])
+  reason: Schema19.Literals([
+    "InvalidName",
+    "Exists",
+    "MessageRequired",
+    "Moved",
+    "RemoteDiffers"
+  ])
 }), RepositoryTagsApi = {
   create: repositoryCommand("repositories/tags/create", {
     request: CreateRepositoryTag,
@@ -1016,6 +1150,11 @@ var TagScope = {
   delete: repositoryCommand("repositories/tags/delete", {
     request: DeleteRepositoryTag,
     success: RepositoryTagDeleted,
+    failure: Schema19.Union([RefMissing, TagRejected])
+  }),
+  annotation: repositoryQuery("repositories/tags/annotation", {
+    request: ReadRepositoryTag,
+    success: RepositoryTagAnnotation,
     failure: RefMissing
   })
 };
@@ -1111,7 +1250,7 @@ function octets(address) {
 }
 
 // src/apps/server/app/server/start-environment-server.ts
-import { Effect as Effect60 } from "effect";
+import { Effect as Effect64 } from "effect";
 
 // src/apps/server/adapters/local-git/git-commands.ts
 import {
@@ -1280,8 +1419,10 @@ function gitArguments(command) {
   ];
 }
 function gitEnvironment(command) {
+  let { GIT_SEQUENCE_EDITOR: _, ...inherited } = process.env;
   return {
-    ...process.env,
+    ...inherited,
+    ...command.environment,
     GIT_EDITOR: "true",
     GIT_OPTIONAL_LOCKS: "0",
     GIT_TERMINAL_PROMPT: "0",
@@ -1371,9 +1512,9 @@ function compareVersions(left, right) {
 }
 
 // src/apps/server/app/server/serve-environment.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import { and, eq as eq4, isNull } from "drizzle-orm";
-import { Effect as Effect59 } from "effect";
+import { Effect as Effect63 } from "effect";
 
 // src/apps/server/adapters/environment-transport/environment-event-publisher.ts
 function createEnvironmentEventPublisher() {
@@ -2173,6 +2314,11 @@ function createEnvironmentHttpHandler(authorization, runEnvironmentEffect, brows
         Effect10.catch(
           (error) => Effect10.sync(() => writeEnvironmentHttpError(response, error))
         ),
+        Effect10.catchCause(
+          () => Effect10.sync(() => {
+            response.headersSent || response.writeHead(500).end();
+          })
+        ),
         Effect10.ensuring(Effect10.sync(() => response.off("close", abort)))
       ),
       abortController.signal
@@ -4742,7 +4888,7 @@ function readConflictSides(git, directory, operation) {
   });
 }
 function baseCommit(git, directory, kind, incoming) {
-  return incoming === null ? Effect28.succeed(null) : kind === "merge" ? firstLine(
+  return incoming === null ? Effect28.succeed(null) : kind === "merge" || kind === "squash" ? firstLine(
     runRepositoryGit(git, directory, ["merge-base", "HEAD", incoming], {
       exitCodes: [0, 1]
     })
@@ -5410,7 +5556,459 @@ function sameOids(left, right) {
 }
 
 // src/apps/server/features/repository-operations/repository-operations.ts
+import { Effect as Effect40 } from "effect";
+
+// src/apps/server/features/repository-operations/cherry-pick.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join8, resolve as resolve4 } from "node:path";
+import { Effect as Effect37 } from "effect";
+
+// src/apps/server/features/repository-operations/operation-outcome.ts
 import { Effect as Effect36 } from "effect";
+function started(outcome, operation) {
+  return { outcome, operation };
+}
+function readCommit(git, directory, rev) {
+  return runRepositoryGit(
+    git,
+    directory,
+    ["rev-parse", "--verify", "--quiet", "--end-of-options", `${rev}^{commit}`],
+    { exitCodes: [0, 1] }
+  ).pipe(Effect36.map((output) => output.trim()));
+}
+function requireGitSuccess(output) {
+  if (output.exitCode === 0) return Effect36.void;
+  let detail = output.stderr || output.stdout || "Git rejected the action. Check the worktree and configured hooks.";
+  return /\.lock['\s:]|another git process/i.test(detail) ? Effect36.fail(repositoryRejected("Busy", detail)) : /would be overwritten by merge/i.test(detail) ? Effect36.fail({
+    ...operationError("WouldOverwrite", detail),
+    paths: detail.split(`
+`).filter((line) => line.startsWith("	")).map((line) => line.trim()).filter((path) => path.length > 0).slice(0, 100)
+  }) : Effect36.fail(
+    operationError(
+      /hook|pre-commit|commit-msg|pre-rebase|not committing merge/i.test(detail) ? "HookFailed" : "GitRejected",
+      detail
+    )
+  );
+}
+function uncertain() {
+  return operationError(
+    "Uncertain",
+    "Git's result could not be confirmed. Refresh the worktree before trying again."
+  );
+}
+function operationFailure(reason, detail) {
+  return Effect36.fail(operationError(reason, detail));
+}
+function operationError(reason, detail) {
+  return { _tag: "OperationFailed", reason, detail: detail.slice(0, 2048) };
+}
+
+// src/apps/server/features/repository-operations/cherry-pick.ts
+function startCherryPick(git, coordination, { worktreePath: directory, expectedHead }, { commits, mainline, result }) {
+  return Effect37.gen(function* () {
+    if ((yield* readCommit(git, directory, "HEAD")) !== expectedHead)
+      return yield* operationFailure("Stale", "HEAD moved. Try again.");
+    let merges = (yield* readParentCounts(git, directory, commits)).filter(
+      (count) => count > 1
+    );
+    if (merges.length > 1)
+      return yield* operationFailure(
+        "Incompatible",
+        "Cherry-pick one merge commit at a time."
+      );
+    if (merges.length === 1 && mainline === null)
+      return yield* operationFailure(
+        "Incompatible",
+        "Choose a parent for the merge commit."
+      );
+    if (mainline !== null && merges.some((count) => mainline > count))
+      return yield* operationFailure(
+        "Incompatible",
+        `The merge commit has no parent ${mainline}.`
+      );
+    if (result === "stage" && (yield* hasStagedChanges(git, directory)))
+      return yield* operationFailure(
+        "Incompatible",
+        "Commit or unstage the staged changes first."
+      );
+    let output = yield* git.run({
+      directory,
+      arguments: [
+        "cherry-pick",
+        ...result === "stage" ? ["--no-commit"] : [],
+        ...mainline === null ? [] : ["-m", String(mainline)],
+        "--end-of-options",
+        ...commits
+      ],
+      timeoutMilliseconds: 12e4
+    }).pipe(Effect37.mapError(uncertain), Effect37.uninterruptible), state = yield* coordination.operation(directory);
+    return output.exitCode !== 0 && (state.kind === "cherry-pick" || result === "stage" && (yield* hasUnmergedPaths(git, directory))) ? started("Stopped", state) : (yield* requireGitSuccess(output), started(result === "stage" ? "Staged" : "Committed", state));
+  });
+}
+function continueStagedCherryPick(git, directory) {
+  return Effect37.gen(function* () {
+    let sequencer = yield* readStagedSequencer(git, directory);
+    if (sequencer === void 0) return !1;
+    if (yield* runRepositoryGit(git, directory, ["cherry-pick", "--quit"]), sequencer.remaining.length === 0) return !0;
+    let output = yield* git.run({
+      directory,
+      arguments: [
+        "cherry-pick",
+        "--no-commit",
+        ...sequencer.mainline === null ? [] : ["-m", sequencer.mainline],
+        "--end-of-options",
+        ...sequencer.remaining
+      ],
+      timeoutMilliseconds: 12e4
+    }).pipe(Effect37.mapError(uncertain));
+    return output.exitCode !== 0 && !(yield* hasUnmergedPaths(git, directory)) && (yield* requireGitSuccess(output)), !0;
+  });
+}
+function readStagedSequencer(git, directory) {
+  return Effect37.gen(function* () {
+    let path = resolve4(
+      directory,
+      (yield* runRepositoryGit(git, directory, [
+        "rev-parse",
+        "--git-path",
+        "sequencer"
+      ])).trim()
+    ), [options, todo] = yield* Effect37.tryPromise({
+      try: () => Promise.all([
+        readFile4(join8(path, "opts"), "utf8"),
+        readFile4(join8(path, "todo"), "utf8")
+      ]),
+      catch: () => {
+      }
+    }).pipe(Effect37.orElseSucceed(() => [null, null]));
+    if (!(options === null || todo === null) && /no-commit\s*=\s*true/.test(options))
+      return {
+        mainline: /mainline\s*=\s*(\d+)/.exec(options)?.[1] ?? null,
+        remaining: todo.split(`
+`).flatMap((line) => /^(?:pick|p)\s+(\S+)/.exec(line)?.[1] ?? []).slice(1)
+      };
+  });
+}
+function readParentCounts(git, directory, commits) {
+  return runRepositoryGit(git, directory, [
+    "rev-list",
+    "--no-walk=unsorted",
+    "--parents",
+    "--end-of-options",
+    ...commits
+  ]).pipe(
+    Effect37.catchTag(
+      "GitFailed",
+      () => operationFailure(
+        "Incompatible",
+        "A selected commit is not in this repository."
+      )
+    ),
+    Effect37.map(
+      (output) => output.split(`
+`).filter((line) => line.length > 0).map((line) => line.split(" ").length - 1)
+    )
+  );
+}
+function hasStagedChanges(git, directory) {
+  return runRepositoryGitOutput(
+    git,
+    directory,
+    ["diff", "--cached", "--quiet"],
+    { exitCodes: [0, 1] }
+  ).pipe(Effect37.map(({ exitCode }) => exitCode === 1));
+}
+function hasUnmergedPaths(git, directory) {
+  return runRepositoryGit(git, directory, ["ls-files", "--unmerged"]).pipe(
+    Effect37.map((unmerged) => unmerged.length > 0)
+  );
+}
+
+// src/apps/server/features/repository-operations/start-operation.ts
+import { Effect as Effect39 } from "effect";
+
+// src/apps/server/features/repository-operations/rebase-plan.ts
+import { Effect as Effect38 } from "effect";
+var todoCommands = {
+  pick: "pick",
+  reword: "pick",
+  edit: "edit",
+  squash: "fixup",
+  fixup: "fixup",
+  drop: "drop"
+};
+function rebasePlanTodo(git, directory, range, plan) {
+  return Effect38.gen(function* () {
+    let replayed = new Map(
+      (yield* runRepositoryGit(git, directory, [
+        "log",
+        "--no-merges",
+        "--format=%H%x00%P%x00%an%x00%ae%x00%ad%x00%s",
+        "--date=raw",
+        range
+      ])).split(`
+`).filter(Boolean).map((line) => {
+        let [commit = "", parents = "", name, email, date, subject] = line.split("\0");
+        return [
+          commit,
+          { parent: parents.split(" ")[0] ?? "", name, email, date, subject }
+        ];
+      })
+    );
+    if (new Set(plan.map((step) => step.commit)).size !== plan.length || replayed.size !== plan.length || plan.some((step) => !replayed.has(step.commit)))
+      return yield* operationFailure(
+        "Stale",
+        "The branch changed since the plan was made. Try again."
+      );
+    let problem = planProblem(plan);
+    if (problem !== void 0)
+      return yield* operationFailure("Incompatible", problem);
+    let signed = (yield* runRepositoryGit(
+      git,
+      directory,
+      ["config", "--type=bool", "--get", "commit.gpgSign"],
+      { exitCodes: [0, 1] }
+    )).trim() === "true", lines = [];
+    for (let step of plan) {
+      let original = replayed.get(step.commit), commit = step.message === null || original === void 0 ? step.commit : (yield* runRepositoryGit(
+        git,
+        directory,
+        [
+          "commit-tree",
+          signed ? "-S" : "--no-gpg-sign",
+          `${step.commit}^{tree}`,
+          ...original.parent === "" ? [] : ["-p", original.parent]
+        ],
+        {
+          input: `${step.message}
+`,
+          environment: {
+            GIT_AUTHOR_NAME: original.name ?? "",
+            GIT_AUTHOR_EMAIL: original.email ?? "",
+            GIT_AUTHOR_DATE: `@${original.date ?? ""}`
+          }
+        }
+      )).trim(), subject = (step.message ?? original?.subject ?? "").split(
+        /\r?\n/
+      )[0];
+      lines.push(`${todoCommands[step.action]} ${commit} # ${subject}`);
+    }
+    return `${lines.join(`
+`)}
+`;
+  });
+}
+function planProblem(plan) {
+  let kept, squashed = !1, unmatched = (head) => head !== void 0 && head.message !== null !== (head.action === "reword" || squashed);
+  for (let step of plan) {
+    if (step.action === "drop") {
+      if (step.message !== null) return "A dropped commit has no message.";
+      continue;
+    }
+    if (folds(step)) {
+      if (kept === void 0)
+        return `${step.commit.slice(0, 8)} has nothing older to fold into.`;
+      if (step.message !== null)
+        return "A folded commit takes the message of its group.";
+      squashed ||= step.action === "squash";
+      continue;
+    }
+    if (unmatched(kept))
+      return `${kept?.commit.slice(0, 8)} needs exactly one message.`;
+    kept = step, squashed = !1;
+  }
+  return unmatched(kept) ? `${kept?.commit.slice(0, 8)} needs exactly one message.` : void 0;
+}
+function folds(step) {
+  return step.action === "squash" || step.action === "fixup";
+}
+
+// src/apps/server/features/repository-operations/start-operation.ts
+function startOperation(git, coordination, command) {
+  let { operation } = command;
+  switch (operation._tag) {
+    case "Merge":
+      return startMerge(git, coordination, command, operation);
+    case "Rebase":
+      return startRebase(git, coordination, command, operation);
+    case "Revert":
+      return revertCommits(git, coordination, command, operation);
+    case "CherryPick":
+      return startCherryPick(git, coordination, command, operation);
+  }
+}
+var mergeArguments = {
+  merge: ["--ff", "--no-edit"],
+  "ff-only": ["--ff-only"],
+  "no-ff": ["--no-ff", "--no-edit"],
+  squash: ["--squash"]
+};
+function startMerge(git, coordination, { worktreePath: directory, expectedHead }, { source, mode }) {
+  let revision = source.ref ?? source.commit;
+  return Effect39.gen(function* () {
+    let head = yield* readCommit(git, directory, "HEAD");
+    if (head !== expectedHead)
+      return yield* operationFailure("Stale", "HEAD moved. Try again.");
+    if (!(yield* onBranch(git, directory)))
+      return yield* operationFailure("Incompatible", "HEAD is detached.");
+    if ((yield* readCommit(git, directory, revision)) !== source.commit)
+      return yield* operationFailure("Stale", `${revision} moved. Try again.`);
+    let base = yield* runRepositoryGit(
+      git,
+      directory,
+      ["merge-base", head, source.commit],
+      { exitCodes: [0, 1] }
+    );
+    if (base.trim() === "")
+      return yield* operationFailure(
+        "Unrelated",
+        `${revision} has no history in common with the current branch.`
+      );
+    if (base.trim() === source.commit)
+      return started("UpToDate", yield* coordination.operation(directory));
+    if (mode === "ff-only" && base.trim() !== head)
+      return yield* operationFailure(
+        "NotFastForward",
+        `Can't fast-forward to ${revision}.`
+      );
+    let output = yield* git.run({
+      directory,
+      arguments: [
+        "merge",
+        "--no-autostash",
+        "--no-stat",
+        ...mergeArguments[mode],
+        "--end-of-options",
+        revision
+      ],
+      timeoutMilliseconds: 12e4
+    }).pipe(Effect39.mapError(uncertain), Effect39.uninterruptible), state = yield* coordination.operation(directory);
+    if (state.phase === "conflicts") return started("Stopped", state);
+    if (yield* requireGitSuccess(output), mode === "squash") return started("Staged", state);
+    let merged = yield* readCommit(git, directory, "HEAD");
+    return started(
+      merged === head ? "UpToDate" : merged === source.commit ? "FastForwarded" : "Committed",
+      state
+    );
+  });
+}
+function startRebase(git, coordination, { worktreePath: directory, expectedHead }, { onto, stash, plan }) {
+  let revision = onto.ref ?? onto.commit;
+  return Effect39.gen(function* () {
+    let [head, branch, target, changes, merges] = yield* Effect39.all(
+      [
+        readCommit(git, directory, "HEAD"),
+        onBranch(git, directory),
+        readCommit(git, directory, revision),
+        runRepositoryGit(
+          git,
+          directory,
+          ["status", "--porcelain=v1", "-z", "--untracked-files=no"],
+          { globalArguments: ["--no-optional-locks"] }
+        ),
+        runRepositoryGit(
+          git,
+          directory,
+          [
+            "rev-list",
+            "--merges",
+            "--max-count=1",
+            `${onto.commit}..${expectedHead}`
+          ],
+          { exitCodes: [0, 128] }
+        )
+      ],
+      { concurrency: "unbounded" }
+    );
+    if (head !== expectedHead)
+      return yield* operationFailure("Stale", "HEAD moved. Try again.");
+    if (!branch)
+      return yield* operationFailure("Incompatible", "HEAD is detached.");
+    if (target !== onto.commit)
+      return yield* operationFailure("Stale", `${revision} moved. Try again.`);
+    if (changes.length > 0 && !stash)
+      return yield* operationFailure(
+        "Stale",
+        "Files changed in the worktree. Try again."
+      );
+    let todo = plan === void 0 ? void 0 : yield* rebasePlanTodo(
+      git,
+      directory,
+      `${onto.commit}..${expectedHead}`,
+      plan
+    ), output = yield* git.run({
+      directory,
+      ...todo === void 0 ? {} : { globalArguments: ["-c", "sequence.editor=cat >"], input: todo },
+      arguments: [
+        "rebase",
+        ...todo === void 0 ? [] : ["--interactive", "--empty=drop"],
+        merges.length > 0 && todo === void 0 ? "--rebase-merges" : "--no-rebase-merges",
+        stash ? "--autostash" : "--no-autostash",
+        "--end-of-options",
+        revision
+      ],
+      timeoutMilliseconds: 6e5
+    }).pipe(Effect39.mapError(uncertain), Effect39.uninterruptible), state = yield* coordination.operation(directory);
+    if (state.kind === "rebase") return started("Stopped", state);
+    if (yield* requireGitSuccess(output), /resulted in conflicts/.test(`${output.stdout}
+${output.stderr}`))
+      return yield* operationFailure(
+        "GitRejected",
+        `${output.stderr}${output.stdout}`
+      );
+    let rebased = yield* readCommit(git, directory, "HEAD");
+    return started(
+      rebased === head ? "UpToDate" : rebased === onto.commit ? "FastForwarded" : "Rebased",
+      state
+    );
+  });
+}
+function revertCommits(git, coordination, { worktreePath: directory, expectedHead }, { commits, commit }) {
+  return Effect39.gen(function* () {
+    if ((yield* readCommit(git, directory, "HEAD")) !== expectedHead)
+      return yield* operationFailure("Stale", "HEAD moved. Try again.");
+    let outside = yield* runRepositoryGit(git, directory, [
+      "rev-list",
+      ...commits,
+      "--not",
+      "HEAD"
+    ]), foreign = commits.find((oid) => outside.includes(oid));
+    if (foreign !== void 0)
+      return yield* operationFailure(
+        "Incompatible",
+        `${foreign.slice(0, 8)} is not in the checked-out branch.`
+      );
+    let output = yield* git.run({
+      directory,
+      arguments: [
+        "revert",
+        "--no-edit",
+        "--mainline",
+        "1",
+        ...commit ? [] : ["--no-commit"],
+        ...commits
+      ],
+      timeoutMilliseconds: 12e4
+    }).pipe(Effect39.mapError(uncertain), Effect39.uninterruptible), state = yield* coordination.operation(directory), empty = /nothing to commit/i.test(
+      `${output.stdout}
+${output.stderr}`
+    );
+    return output.exitCode === 0 ? started(commit ? "Committed" : "Staged", state) : state.kind === "revert" && (state.phase === "conflicts" || empty) ? started("Stopped", state) : empty ? yield* operationFailure(
+      "Empty",
+      "Nothing to revert. The changes are already undone."
+    ) : (yield* requireGitSuccess(output), started("Stopped", state));
+  });
+}
+function onBranch(git, directory) {
+  return runRepositoryGitOutput(
+    git,
+    directory,
+    ["symbolic-ref", "--quiet", "HEAD"],
+    { exitCodes: [0, 1] }
+  ).pipe(Effect39.map((output) => output.exitCode === 0));
+}
+
+// src/apps/server/features/repository-operations/repository-operations.ts
 function repositoryOperationsFeature(dependencies) {
   let { command, query } = repositoryRoutes(dependencies), { coordination } = dependencies, api = RepositoryOperationsApi;
   return {
@@ -5424,42 +6022,45 @@ function repositoryOperationsFeature(dependencies) {
           duringOperation: "proceed"
         },
         (input, git) => recoverRepositoryOperation(git, coordination, input)
+      ),
+      command(
+        api.start,
+        (input) => ({
+          name: input.operation._tag.toLowerCase(),
+          locks: { refs: "wait", worktree: "wait" },
+          duringOperation: "block"
+        }),
+        (input, git) => startOperation(git, coordination, input)
       )
     ]
   };
 }
 function recoverRepositoryOperation(git, coordination, command) {
-  return Effect36.gen(function* () {
+  return Effect40.gen(function* () {
     let state = yield* coordination.operation(command.worktreePath);
-    yield* validateRecoveryAction(state, command);
+    if (yield* validateRecoveryAction(state, command), state.kind === "cherry-pick" && command.action === "continue" && (yield* continueStagedCherryPick(git, command.worktreePath)))
+      return yield* coordination.operation(command.worktreePath).pipe(Effect40.mapError(uncertain));
     let output = yield* git.run({
       directory: command.worktreePath,
-      arguments: [state.kind, `--${command.action}`],
+      arguments: state.kind === "squash" ? ["reset", "--merge"] : [state.kind, `--${command.action}`],
       timeoutMilliseconds: 12e4
-    }).pipe(
-      Effect36.mapError(
-        () => operationError(
-          "Uncertain",
-          "Git's result could not be confirmed. Refresh the worktree before trying again."
-        )
-      )
-    ), operation = yield* coordination.operation(command.worktreePath).pipe(
-      Effect36.mapError(
+    }).pipe(Effect40.mapError(uncertain)), operation = yield* coordination.operation(command.worktreePath).pipe(
+      Effect40.mapError(
         () => operationError(
           "Uncertain",
           "Git finished, but its current state could not be read."
         )
       )
     );
-    return (command.action === "abort" || !advancedToConflict(state, operation)) && (yield* requireRecoverySuccess(output)), operation;
-  }).pipe(Effect36.uninterruptible);
+    return (command.action === "abort" || !advancedToStop(state, operation)) && (yield* requireGitSuccess(output)), operation;
+  }).pipe(Effect40.uninterruptible);
 }
-function advancedToConflict(previous, current) {
-  return current.kind === previous.kind && current.phase === "conflicts" && (current.commit !== null && current.commit !== previous.commit || current.progress !== null && previous.progress !== null && current.progress.current > previous.progress.current);
+function advancedToStop(previous, current) {
+  return current.kind === previous.kind && (current.phase === "conflicts" || current.phase === "empty") && (current.commit !== null && current.commit !== previous.commit || current.progress !== null && previous.progress !== null && current.progress.current > previous.progress.current);
 }
 function validateRecoveryAction(state, command) {
   if (state.revision !== command.revision)
-    return Effect36.fail(
+    return Effect40.fail(
       operationError(
         "Stale",
         "Git state changed. Review the refreshed operation before trying again."
@@ -5468,44 +6069,31 @@ function validateRecoveryAction(state, command) {
   let action = state.actions.find(
     (candidate) => candidate.action === command.action
   );
-  if (action?.enabled) return Effect36.void;
+  if (action?.enabled) return Effect40.void;
   let detail = action?.reason ?? "This action is not supported by the current Git state.";
-  return Effect36.fail(
+  return Effect40.fail(
     state.lock ? repositoryRejected("Busy", detail) : operationError("Incompatible", detail)
   );
 }
-function requireRecoverySuccess(output) {
-  if (output.exitCode === 0) return Effect36.void;
-  let detail = output.stderr || output.stdout || "Git rejected the action. Check the worktree and configured hooks.";
-  return /\.lock['\s:]|another git process/i.test(detail) ? Effect36.fail(repositoryRejected("Busy", detail)) : Effect36.fail(
-    operationError(
-      /hook|pre-commit|commit-msg|pre-rebase/i.test(detail) ? "HookFailed" : "GitRejected",
-      detail
-    )
-  );
-}
-function operationError(reason, detail) {
-  return { _tag: "OperationFailed", reason, detail: detail.slice(0, 2048) };
-}
 
 // src/apps/server/features/repository-pull/repository-pull.feature.ts
-import { Effect as Effect40 } from "effect";
+import { Effect as Effect44 } from "effect";
 
 // src/apps/server/features/repository-pull/fast-forward-branch.ts
-import { Effect as Effect37 } from "effect";
+import { Effect as Effect41 } from "effect";
 var pullCommand = { timeoutMilliseconds: 6e4 };
 function fastForwardBranch(git, directory, branch, checkedOut) {
-  return Effect37.gen(function* () {
+  return Effect41.gen(function* () {
     let tracked = yield* readTrackedBranch(git, directory, branch), upstreamTarget = yield* resolveUpstream(git, directory, tracked), { ahead, behind } = yield* countDivergence(
       git,
       directory,
       tracked.target,
       upstreamTarget
     );
-    return behind === 0 ? { outcome: "UpToDate" } : ahead > 0 ? yield* Effect37.fail({
+    return behind === 0 ? { outcome: "UpToDate" } : ahead > 0 ? yield* Effect41.fail({
       _tag: "PullDiverged",
       upstream: tracked.upstream
-    }) : (yield* Effect37.uninterruptible(
+    }) : (yield* Effect41.uninterruptible(
       checkedOut ? mergeFastForward(git, directory, tracked, upstreamTarget) : moveBranch(git, directory, tracked, upstreamTarget)
     ), { outcome: "FastForwarded" });
   });
@@ -5522,10 +6110,10 @@ function readTrackedBranch(git, directory, branch) {
     ],
     pullCommand
   ).pipe(
-    Effect37.flatMap((output) => {
+    Effect41.flatMap((output) => {
       let [, target, upstreamRef, upstream] = output.split(`
 `).map((line) => line.split("\0")).find(([name]) => name === ref) ?? [];
-      return target === void 0 ? Effect37.fail({ _tag: "BranchMissing" }) : !upstreamRef || !upstream ? Effect37.fail({ _tag: "UpstreamMissing" }) : Effect37.succeed({
+      return target === void 0 ? Effect41.fail({ _tag: "BranchMissing" }) : !upstreamRef || !upstream ? Effect41.fail({ _tag: "UpstreamMissing" }) : Effect41.succeed({
         name: branch,
         target,
         upstreamRef,
@@ -5541,11 +6129,11 @@ function resolveUpstream(git, directory, tracked) {
     ["rev-parse", "--verify", "--quiet", `${tracked.upstreamRef}^{commit}`],
     { ...pullCommand, exitCodes: [0, 1] }
   ).pipe(
-    Effect37.flatMap(
-      (output) => output.trim() === "" ? Effect37.fail({
+    Effect41.flatMap(
+      (output) => output.trim() === "" ? Effect41.fail({
         _tag: "UpstreamMissing",
         upstream: tracked.upstream
-      }) : Effect37.succeed(output.trim())
+      }) : Effect41.succeed(output.trim())
     )
   );
 }
@@ -5556,7 +6144,7 @@ function countDivergence(git, directory, target, upstreamTarget) {
     ["rev-list", "--left-right", "--count", `${target}...${upstreamTarget}`],
     pullCommand
   ).pipe(
-    Effect37.map((output) => {
+    Effect41.map((output) => {
       let [ahead = 0, behind = 0] = output.trim().split(/\s+/).map(Number);
       return { ahead, behind };
     })
@@ -5576,8 +6164,8 @@ function mergeFastForward(git, directory, tracked, upstreamTarget) {
     ],
     pullCommand
   ).pipe(
-    Effect37.asVoid,
-    Effect37.mapError((error) => mergeFailure(error, tracked))
+    Effect41.asVoid,
+    Effect41.mapError((error) => mergeFailure(error, tracked))
   );
 }
 function mergeFailure(error, tracked) {
@@ -5604,8 +6192,8 @@ function moveBranch(git, directory, tracked, upstreamTarget) {
     ],
     pullCommand
   ).pipe(
-    Effect37.asVoid,
-    Effect37.mapError(
+    Effect41.asVoid,
+    Effect41.mapError(
       (error) => isGitRejection(error) ? branchMoved(tracked) : { _tag: "PullUncertain" }
     )
   );
@@ -5618,7 +6206,7 @@ function pullBlocked(detail) {
 }
 
 // src/apps/server/features/repository-pull/repository-fetch.ts
-import { Cause, Effect as Effect38, Fiber as Fiber2, Option, Semaphore } from "effect";
+import { Cause, Effect as Effect42, Fiber as Fiber2, Option, Semaphore } from "effect";
 var defaultIntervalSeconds = 300, maximumFetchedRepositories = 32, settingKey = "rebase.autoFetchIntervalSeconds";
 function acquireRepositoryFetch({
   access,
@@ -5626,24 +6214,24 @@ function acquireRepositoryFetch({
   events,
   git
 }) {
-  return Effect38.gen(function* () {
-    let scope = yield* Effect38.scope, mutex = yield* Semaphore.make(1), repositories = /* @__PURE__ */ new Map(), status = (repository) => ({
+  return Effect42.gen(function* () {
+    let scope = yield* Effect42.scope, mutex = yield* Semaphore.make(1), repositories = /* @__PURE__ */ new Map(), status = (repository) => ({
       fetching: repository.fetching !== void 0,
       defaultIntervalSeconds,
       setting: repository.setting,
       ...repository.failure === void 0 ? {} : { failure: repository.failure }
-    }), publish = (repository) => events.publishChanged([...repository.repositoryIds], "Fetch"), schedule = (repository) => Effect38.gen(function* () {
+    }), publish = (repository) => events.publishChanged([...repository.repositoryIds], "Fetch"), schedule = (repository) => Effect42.gen(function* () {
       let previous = repository.schedule;
       if (repository.schedule = void 0, previous !== void 0 && (yield* Fiber2.interrupt(previous)), repository.fetching !== void 0 || repository.setting._tag === "Disabled")
         return;
       let seconds = repository.setting._tag === "Interval" ? repository.setting.seconds : defaultIntervalSeconds;
-      repository.schedule = yield* Effect38.sleep(seconds * 1e3).pipe(
-        Effect38.andThen(tick(repository)),
-        Effect38.forkIn(scope)
+      repository.schedule = yield* Effect42.sleep(seconds * 1e3).pipe(
+        Effect42.andThen(tick(repository)),
+        Effect42.forkIn(scope)
       );
-    }), tick = (repository) => Effect38.gen(function* () {
+    }), tick = (repository) => Effect42.gen(function* () {
       repository.schedule = void 0, events.listening() ? yield* begin(repository) : yield* schedule(repository);
-    }).pipe(Semaphore.withPermit(mutex)), begin = (repository) => Effect38.gen(function* () {
+    }).pipe(Semaphore.withPermit(mutex)), begin = (repository) => Effect42.gen(function* () {
       if (repository.fetching !== void 0) return repository.fetching;
       let previous = repository.schedule;
       repository.schedule = void 0, previous !== void 0 && (yield* Fiber2.interrupt(previous));
@@ -5652,15 +6240,15 @@ function acquireRepositoryFetch({
         coordination,
         repository.path
       ).pipe(
-        Effect38.tap(
-          (failure) => Effect38.gen(function* () {
+        Effect42.tap(
+          (failure) => Effect42.gen(function* () {
             repository.fetching = void 0, failure === void 0 ? delete repository.failure : repository.failure = failure, publish(repository), yield* schedule(repository);
           }).pipe(Semaphore.withPermit(mutex))
         ),
-        Effect38.forkIn(scope)
+        Effect42.forkIn(scope)
       );
       return repository.fetching = fetching, publish(repository), fetching;
-    }), register = (repositoryId) => Effect38.gen(function* () {
+    }), register = (repositoryId) => Effect42.gen(function* () {
       let entry = yield* access.repository(repositoryId), key = entry.logicalRepositoryId ?? entry.id, known = repositories.get(key);
       if (known !== void 0)
         return known.repositoryIds.add(repositoryId), repositories.delete(key), repositories.set(key, known), known;
@@ -5670,28 +6258,28 @@ function acquireRepositoryFetch({
         setting: yield* readFetchSetting(git, entry.path)
       };
       return repositories.set(key, repository), yield* evictOldest, repository.setting._tag !== "Disabled" && (yield* begin(repository)), repository;
-    }).pipe(Semaphore.withPermit(mutex)), evictOldest = Effect38.suspend(() => {
+    }).pipe(Semaphore.withPermit(mutex)), evictOldest = Effect42.suspend(() => {
       let oldest = repositories.entries().next().value;
       if (repositories.size <= maximumFetchedRepositories || oldest === void 0)
-        return Effect38.void;
+        return Effect42.void;
       repositories.delete(oldest[0]);
       let { schedule: scheduled, fetching } = oldest[1];
-      return Effect38.all([
-        scheduled === void 0 ? Effect38.void : Fiber2.interrupt(scheduled),
-        fetching === void 0 ? Effect38.void : Fiber2.interrupt(fetching)
+      return Effect42.all([
+        scheduled === void 0 ? Effect42.void : Fiber2.interrupt(scheduled),
+        fetching === void 0 ? Effect42.void : Fiber2.interrupt(fetching)
       ]);
     });
     return {
-      status: (repositoryId) => register(repositoryId).pipe(Effect38.map(status)),
-      fetch: (repositoryId) => Effect38.gen(function* () {
+      status: (repositoryId) => register(repositoryId).pipe(Effect42.map(status)),
+      fetch: (repositoryId) => Effect42.gen(function* () {
         let repository = yield* register(repositoryId), fetching = yield* begin(repository).pipe(
           Semaphore.withPermit(mutex)
         ), failure = yield* Fiber2.join(fetching);
-        return failure !== void 0 ? yield* Effect38.fail(failure) : status(repository);
+        return failure !== void 0 ? yield* Effect42.fail(failure) : status(repository);
       }),
-      configure: (repositoryId, setting) => Effect38.gen(function* () {
+      configure: (repositoryId, setting) => Effect42.gen(function* () {
         let repository = yield* register(repositoryId);
-        return yield* Effect38.gen(function* () {
+        return yield* Effect42.gen(function* () {
           return yield* writeFetchSetting(git, repository.path, setting), repository.setting = setting, yield* schedule(repository), publish(repository), status(repository);
         }).pipe(Semaphore.withPermit(mutex));
       })
@@ -5708,12 +6296,12 @@ function runFetch(git, coordination, path) {
     },
     runRepositoryGit(git, path, ["fetch"], { timeoutMilliseconds: 12e4 })
   ).pipe(
-    Effect38.as(void 0),
-    Effect38.catchCause((cause) => {
+    Effect42.as(void 0),
+    Effect42.catchCause((cause) => {
       if (Cause.hasInterrupts(cause))
-        return Effect38.failCause(Cause.interrupt());
+        return Effect42.failCause(Cause.interrupt());
       let error = Cause.findErrorOption(cause);
-      return Effect38.succeed({
+      return Effect42.succeed({
         _tag: "FetchFailed",
         reason: Option.isSome(error) && error.value._tag === "GitFailed" ? error.value.reason : "Failed"
       });
@@ -5727,11 +6315,11 @@ function readFetchSetting(git, path) {
     ["config", "--local", "--get", settingKey],
     { exitCodes: [0, 1] }
   ).pipe(
-    Effect38.map((output) => {
+    Effect42.map((output) => {
       let value = output.trim(), seconds = Number(value);
       return value === "0" ? { _tag: "Disabled" } : Number.isInteger(seconds) && seconds > 0 && seconds <= 86400 ? { _tag: "Interval", seconds } : { _tag: "Inherit" };
     }),
-    Effect38.mapError(settingsUnavailable)
+    Effect42.mapError(settingsUnavailable)
   );
 }
 function writeFetchSetting(git, path, setting) {
@@ -5741,7 +6329,7 @@ function writeFetchSetting(git, path, setting) {
     "--local",
     settingKey,
     value
-  ]).pipe(Effect38.asVoid, Effect38.mapError(settingsUnavailable));
+  ]).pipe(Effect42.asVoid, Effect42.mapError(settingsUnavailable));
 }
 function settingsUnavailable() {
   return repositoryRejected(
@@ -5753,29 +6341,29 @@ function settingsUnavailable() {
 // src/apps/server/repository/repository-access.ts
 import { realpath as realpath4 } from "node:fs";
 import { promisify as promisify3 } from "node:util";
-import { Effect as Effect39 } from "effect";
+import { Effect as Effect43 } from "effect";
 var realpathNative3 = promisify3(realpath4.native), branchPrefix = "refs/heads/";
 function createRepositoryAccess(catalog, git, watcher) {
   let worktreePaths = createWorktreePathCache(git, watcher), repository = (repositoryId) => catalog.find(repositoryId).pipe(
-    Effect39.flatMap(
-      (entry) => entry === void 0 ? Effect39.fail(
+    Effect43.flatMap(
+      (entry) => entry === void 0 ? Effect43.fail(
         repositoryRejected(
           "Missing",
           "This repository is no longer available."
         )
-      ) : Effect39.succeed(entry)
+      ) : Effect43.succeed(entry)
     )
   );
   return {
     repository,
     worktrees: (repositoryPath) => readWorktrees(git, repositoryPath).pipe(
-      Effect39.flatMap(canonicalizeWorktrees),
-      Effect39.mapError(worktreesUnreadable)
+      Effect43.flatMap(canonicalizeWorktrees),
+      Effect43.mapError(worktreesUnreadable)
     ),
-    requireWorktree: (scope) => Effect39.gen(function* () {
+    requireWorktree: (scope) => Effect43.gen(function* () {
       let entry = yield* repository(scope.repositoryId);
-      if (!(yield* worktreePaths.contains(entry.path, scope.worktreePath).pipe(Effect39.mapError(worktreesUnreadable))))
-        return yield* Effect39.fail(
+      if (!(yield* worktreePaths.contains(entry.path, scope.worktreePath).pipe(Effect43.mapError(worktreesUnreadable))))
+        return yield* Effect43.fail(
           repositoryRejected(
             "Missing",
             "This worktree does not belong to the repository."
@@ -5790,12 +6378,12 @@ function readWorktrees(git, directory) {
     directory,
     ["worktree", "list", "--porcelain", "-z"],
     { timeoutMilliseconds: 15e3 }
-  ).pipe(Effect39.map(parseWorktreeList));
+  ).pipe(Effect43.map(parseWorktreeList));
 }
 function canonicalizeWorktrees(worktrees) {
-  return Effect39.all(
+  return Effect43.all(
     worktrees.map(
-      (worktree) => Effect39.promise(async () => ({
+      (worktree) => Effect43.promise(async () => ({
         ...worktree,
         path: await realpathNative3(worktree.path).catch(() => worktree.path)
       }))
@@ -5816,13 +6404,13 @@ function createWorktreePathCache(git, watcher) {
     entry.watch = void 0, watch3?.close();
   }, reload = (repositoryPath) => {
     let entry = {}, changed = !1;
-    return Effect39.gen(function* () {
+    return Effect43.gen(function* () {
       let directory = yield* readGitCommonDirectory(git, repositoryPath);
       entry.watch = yield* watcher.watch(directory, (kind) => {
         kind !== "Index" && (changed = !0, forget(repositoryPath, entry));
       });
       let worktrees = yield* readWorktrees(git, repositoryPath).pipe(
-        Effect39.flatMap(canonicalizeWorktrees)
+        Effect43.flatMap(canonicalizeWorktrees)
       );
       if (entry.paths = new Set(worktrees.map((worktree) => worktree.path)), !changed) {
         let previous = cache.get(repositoryPath);
@@ -5830,16 +6418,16 @@ function createWorktreePathCache(git, watcher) {
       }
       return entry.paths;
     }).pipe(
-      Effect39.onExit(
-        () => Effect39.sync(() => {
+      Effect43.onExit(
+        () => Effect43.sync(() => {
           cache.get(repositoryPath) !== entry && forget(repositoryPath, entry);
         })
       )
     );
   };
   return {
-    contains: (repositoryPath, worktreePath) => cache.get(repositoryPath)?.paths?.has(worktreePath) ? Effect39.succeed(!0) : reload(repositoryPath).pipe(
-      Effect39.map((paths) => paths.has(worktreePath))
+    contains: (repositoryPath, worktreePath) => cache.get(repositoryPath)?.paths?.has(worktreePath) ? Effect43.succeed(!0) : reload(repositoryPath).pipe(
+      Effect43.map((paths) => paths.has(worktreePath))
     )
   };
 }
@@ -5882,7 +6470,7 @@ function worktreeFromEntry(entry, main2) {
 
 // src/apps/server/features/repository-pull/repository-pull.feature.ts
 function repositoryPullFeature(dependencies) {
-  return Effect40.gen(function* () {
+  return Effect44.gen(function* () {
     let { command } = repositoryRoutes(dependencies), fetch = yield* acquireRepositoryFetch(dependencies);
     return {
       routes: [
@@ -5912,7 +6500,7 @@ function repositoryPullFeature(dependencies) {
   });
 }
 function pullBranch(coordination) {
-  return (command, git) => Effect40.gen(function* () {
+  return (command, git) => Effect44.gen(function* () {
     let checkout = yield* findCheckout(git, command), directory = checkout ?? command.worktreePath;
     return yield* coordination.run(
       directory,
@@ -5922,7 +6510,7 @@ function pullBranch(coordination) {
         duringOperation: "block"
       },
       requireSameCheckout(git, command, checkout).pipe(
-        Effect40.andThen(
+        Effect44.andThen(
           fastForwardBranch(
             git,
             directory,
@@ -5936,7 +6524,7 @@ function pullBranch(coordination) {
 }
 function requireSameCheckout(git, command, checkout) {
   return findCheckout(git, command).pipe(
-    Effect40.filterOrFail(
+    Effect44.filterOrFail(
       (current) => current === checkout,
       () => pullBlocked(`${command.branch} was checked out while pulling`)
     )
@@ -5944,15 +6532,15 @@ function requireSameCheckout(git, command, checkout) {
 }
 function findCheckout(git, command) {
   return readWorktrees(git, command.worktreePath).pipe(
-    Effect40.flatMap(canonicalizeWorktrees),
-    Effect40.map(
+    Effect44.flatMap(canonicalizeWorktrees),
+    Effect44.map(
       (worktrees) => worktrees.find((worktree) => worktree.head.branch === command.branch)?.path
     )
   );
 }
 
 // src/apps/server/features/repository-push/repository-push.ts
-import { Effect as Effect42 } from "effect";
+import { Effect as Effect46 } from "effect";
 
 // src/apps/server/features/repository-push/git/push-failures.ts
 function pushError(reason, detail) {
@@ -5993,11 +6581,11 @@ function classifyPushFailure(output, destinationRef) {
 }
 
 // src/apps/server/features/repository-push/git/reconcile-remote-branch.ts
-import { Effect as Effect41 } from "effect";
+import { Effect as Effect45 } from "effect";
 var reconcileTimeoutMilliseconds = 3e4;
 function reconcileRemoteBranch(git, directory, { remote, branch }) {
   let remoteRef = `refs/heads/${branch}`, trackingRef = `refs/remotes/${remote}/${branch}`, options = { timeoutMilliseconds: reconcileTimeoutMilliseconds };
-  return Effect41.gen(function* () {
+  return Effect45.gen(function* () {
     let target = (yield* runRepositoryGit(
       git,
       directory,
@@ -6026,13 +6614,13 @@ function reconcileRemoteBranch(git, directory, { remote, branch }) {
 function uncertainPush(git, directory, destination) {
   let name = `${destination.remote}/${destination.branch}`;
   return reconcileRemoteBranch(git, directory, destination).pipe(
-    Effect41.map(
+    Effect45.map(
       (target) => target === null ? `Push unconfirmed. ${name} no longer exists.` : `Push unconfirmed. ${name} is at ${target.slice(0, 8)}.`
     ),
-    Effect41.orElseSucceed(
+    Effect45.orElseSucceed(
       () => `Push unconfirmed and ${name} could not be read. Fetch to check.`
     ),
-    Effect41.flatMap((detail) => Effect41.fail(pushError("Uncertain", detail)))
+    Effect45.flatMap((detail) => Effect45.fail(pushError("Uncertain", detail)))
   );
 }
 
@@ -6040,7 +6628,7 @@ function uncertainPush(git, directory, destination) {
 var pushTimeoutMilliseconds = 12e4;
 function pushRemoteBranch(git, command) {
   let directory = command.worktreePath, destinationRef = `refs/heads/${command.destination.branch}`;
-  return Effect42.gen(function* () {
+  return Effect46.gen(function* () {
     yield* requireDestination(git, directory, command.destination);
     let target = yield* readBranchTip(git, directory, command.branch);
     return yield* runPush(
@@ -6059,18 +6647,66 @@ function pushRemoteBranch(git, command) {
     };
   });
 }
+function pushTagsToRemote(git, { worktreePath, remote, tags }) {
+  let refs = tags.map((tag) => `refs/tags/${tag}`);
+  return Effect46.gen(function* () {
+    yield* requireRemote(git, worktreePath, remote);
+    let output = yield* git.run({
+      directory: worktreePath,
+      arguments: [
+        "push",
+        "--porcelain",
+        "--atomic",
+        remote,
+        ...refs.map((ref) => `${ref}:${ref}`)
+      ],
+      timeoutMilliseconds: pushTimeoutMilliseconds
+    }).pipe(
+      Effect46.mapError(
+        (error) => error.reason === "Timeout" ? pushError(
+          "Uncertain",
+          `The push to ${remote} did not finish. Fetch to see which tags arrived.`
+        ) : repositoryRejected(
+          "GitFailed",
+          `Git could not run the push (${error.reason}).`
+        )
+      )
+    ), statuses = tags.map((tag, index2) => ({
+      tag,
+      status: pushRefStatus(output.stdout, refs[index2] ?? "")
+    }));
+    if (output.exitCode === 0)
+      return {
+        remote,
+        pushed: statuses.filter(({ status }) => status?.flag !== "=").map(({ tag }) => tag),
+        upToDate: statuses.filter(({ status }) => status?.flag === "=").map(({ tag }) => tag)
+      };
+    let existing = statuses.filter(({ status }) => status?.summary.includes("(already exists)")).map(({ tag }) => tag);
+    return yield* Effect46.fail(
+      existing.length > 0 ? pushError("TagExists", existing.join(", ")) : classifyPushFailure(output, refs[0] ?? "")
+    );
+  });
+}
+function requireRemote(git, directory, remote) {
+  return runRepositoryGit(git, directory, ["remote"]).pipe(
+    Effect46.flatMap(
+      (remotes) => remotes.split(`
+`).includes(remote) ? Effect46.void : Effect46.fail(
+        pushError(
+          "RemoteMissing",
+          `The remote "${remote}" does not exist.`
+        )
+      )
+    )
+  );
+}
 function requireDestination(git, directory, { remote, branch }) {
-  return Effect42.gen(function* () {
-    if (!(yield* runRepositoryGit(git, directory, ["remote"])).split(`
-`).includes(remote))
-      return yield* Effect42.fail(
-        pushError("RemoteMissing", `The remote "${remote}" does not exist.`)
-      );
-    yield* runRepositoryGit(git, directory, [
+  return Effect46.gen(function* () {
+    yield* requireRemote(git, directory, remote), yield* runRepositoryGit(git, directory, [
       "check-ref-format",
       `refs/heads/${branch}`
     ]).pipe(
-      Effect42.mapError(
+      Effect46.mapError(
         () => pushError("InvalidBranch", `"${branch}" is not a valid branch name.`)
       )
     );
@@ -6083,8 +6719,8 @@ function readBranchTip(git, directory, branch) {
     "--quiet",
     `refs/heads/${branch}^{commit}`
   ]).pipe(
-    Effect42.map((output) => output.trim()),
-    Effect42.mapError(
+    Effect46.map((output) => output.trim()),
+    Effect46.mapError(
       () => pushError("InvalidBranch", `The branch "${branch}" does not exist.`)
     )
   );
@@ -6096,23 +6732,23 @@ function runPush(git, directory, args, destination) {
     arguments: ["push", "--porcelain", ...args],
     timeoutMilliseconds: pushTimeoutMilliseconds
   }).pipe(
-    Effect42.catch(
-      (error) => error.reason === "Timeout" ? uncertainPush(git, directory, destination) : Effect42.fail(
+    Effect46.catch(
+      (error) => error.reason === "Timeout" ? uncertainPush(git, directory, destination) : Effect46.fail(
         repositoryRejected(
           "GitFailed",
           `Git could not run the push (${error.reason}).`
         )
       )
     ),
-    Effect42.flatMap((output) => requirePushed(output, destinationRef)),
-    Effect42.onInterrupt(
-      () => reconcileRemoteBranch(git, directory, destination).pipe(Effect42.ignore)
+    Effect46.flatMap((output) => requirePushed(output, destinationRef)),
+    Effect46.onInterrupt(
+      () => reconcileRemoteBranch(git, directory, destination).pipe(Effect46.ignore)
     )
   );
 }
 function requirePushed(output, destinationRef) {
   let status = pushRefStatus(output.stdout, destinationRef);
-  return output.exitCode === 0 && status !== void 0 && status.flag !== "!" ? Effect42.void : Effect42.fail(classifyPushFailure(output, destinationRef));
+  return output.exitCode === 0 && status !== void 0 && status.flag !== "!" ? Effect46.void : Effect46.fail(classifyPushFailure(output, destinationRef));
 }
 function repositoryPushFeature(dependencies) {
   let { command } = repositoryRoutes(dependencies);
@@ -6122,6 +6758,11 @@ function repositoryPushFeature(dependencies) {
         RepositoryPushApi.push,
         { name: "push", locks: { refs: "wait" }, duringOperation: "block" },
         (input, git) => pushRemoteBranch(git, input)
+      ),
+      command(
+        RepositoryPushApi.pushTags,
+        { name: "push", locks: { refs: "wait" }, duringOperation: "proceed" },
+        (input, git) => pushTagsToRemote(git, input)
       )
     ]
   };
@@ -6129,7 +6770,7 @@ function repositoryPushFeature(dependencies) {
 
 // src/apps/server/features/repository-reflog/repository-reflog.ts
 import { createHash as createHash3 } from "node:crypto";
-import { Effect as Effect44 } from "effect";
+import { Effect as Effect48 } from "effect";
 
 // src/apps/server/features/repository-reflog/reflog-entries.ts
 function parseReflog(output) {
@@ -6248,7 +6889,7 @@ function text2(value) {
 }
 
 // src/apps/server/features/repository-refs/git/ref-git.ts
-import { Effect as Effect43 } from "effect";
+import { Effect as Effect47 } from "effect";
 var refCommand = {
   literalPathspecs: !1,
   timeoutMilliseconds: 3e4
@@ -6260,8 +6901,8 @@ function requireValidRefName(git, directory, fullRef, invalid) {
     ["check-ref-format", fullRef],
     refCommand
   ).pipe(
-    Effect43.catchIf(isGitRejection, () => Effect43.fail(invalid)),
-    Effect43.asVoid
+    Effect47.catchIf(isGitRejection, () => Effect47.fail(invalid)),
+    Effect47.asVoid
   );
 }
 function readRefTarget(git, directory, revision) {
@@ -6270,7 +6911,7 @@ function readRefTarget(git, directory, revision) {
     directory,
     ["rev-parse", "--verify", "--quiet", revision],
     { ...refCommand, exitCodes: [0, 1] }
-  ).pipe(Effect43.map((output) => output.trim() || void 0));
+  ).pipe(Effect47.map((output) => output.trim() || void 0));
 }
 
 // src/apps/server/features/repository-reflog/repository-reflog.ts
@@ -6293,8 +6934,8 @@ function repositoryReflogFeature(dependencies) {
   };
 }
 function readReflog(git, { worktreePath, ref }) {
-  return Effect44.gen(function* () {
-    let [output, tips] = yield* Effect44.all(
+  return Effect48.gen(function* () {
+    let [output, tips] = yield* Effect48.all(
       [
         readReflogOutput(git, worktreePath, ref),
         runRepositoryGit(
@@ -6339,20 +6980,20 @@ function readReflogOutput(git, directory, ref) {
     ],
     { maxOutputBytes: 8 * 1048576 }
   ).pipe(
-    Effect44.catchIf(
+    Effect48.catchIf(
       (error) => /does not have any commits yet/i.test(error.detail),
-      () => Effect44.succeed("")
+      () => Effect48.succeed("")
     )
   );
 }
 function readOrphaned(git, directory, oids, tips) {
-  return oids.length === 0 ? Effect44.succeed(/* @__PURE__ */ new Set()) : runRepositoryGit(git, directory, ["rev-list", "--stdin"], {
+  return oids.length === 0 ? Effect48.succeed(/* @__PURE__ */ new Set()) : runRepositoryGit(git, directory, ["rev-list", "--stdin"], {
     input: `${[...oids, ...tips.map((tip) => `^${tip}`)].join(`
 `)}
 `,
     maxOutputBytes: 64 * 1048576
   }).pipe(
-    Effect44.map((output) => {
+    Effect48.map((output) => {
       let candidates = new Set(oids);
       return new Set(
         output.split(`
@@ -6363,10 +7004,10 @@ function readOrphaned(git, directory, oids, tips) {
 }
 function resetToCommit(git, command) {
   let { worktreePath, target, mode, expectedHead, discard } = command;
-  return Effect44.gen(function* () {
+  return Effect48.gen(function* () {
     let head = yield* readRefTarget(git, worktreePath, "HEAD");
     if (head !== expectedHead)
-      return yield* Effect44.fail({
+      return yield* Effect48.fail({
         _tag: "HeadMoved",
         head: head ?? null
       });
@@ -6375,7 +7016,7 @@ function resetToCommit(git, command) {
       worktreePath,
       `${target}^{commit}`
     );
-    return commit === void 0 ? yield* Effect44.fail({
+    return commit === void 0 ? yield* Effect48.fail({
       _tag: "RefMissing",
       name: target
     }) : (mode === "hard" && (yield* requireDiscardConfirmed(git, worktreePath, commit, discard)), yield* runRepositoryGit(
@@ -6387,7 +7028,7 @@ function resetToCommit(git, command) {
   });
 }
 function requireDiscardConfirmed(git, directory, target, discard) {
-  return Effect44.gen(function* () {
+  return Effect48.gen(function* () {
     let records = (yield* runRepositoryGit(
       git,
       directory,
@@ -6409,7 +7050,7 @@ function requireDiscardConfirmed(git, directory, target, discard) {
     if (paths.length === 0) return;
     let fingerprint2 = createHash3("sha256").update(paths.join("\0")).digest("hex");
     if (discard !== fingerprint2)
-      return yield* Effect44.fail({
+      return yield* Effect48.fail({
         _tag: "ResetDiscardsChanges",
         paths: paths.slice(0, listedDiscards),
         count: paths.length,
@@ -6424,7 +7065,7 @@ function readOverwrittenUntracked(git, directory, target, untracked) {
     ["diff", "--name-only", "-z", "--no-renames", "HEAD", target],
     { maxOutputBytes: 64 * 1048576 }
   ).pipe(
-    Effect44.map((output) => {
+    Effect48.map((output) => {
       let changed = new Set(output.split("\0"));
       return untracked.filter((path) => changed.has(path));
     })
@@ -6432,7 +7073,7 @@ function readOverwrittenUntracked(git, directory, target, untracked) {
 }
 
 // src/apps/server/features/repository-refs/repository-refs.feature.ts
-import { Effect as Effect52 } from "effect";
+import { Effect as Effect56 } from "effect";
 
 // src/apps/server/features/repository-refs/git/branches/branch-failures.ts
 function branchWriteFailed(error, name) {
@@ -6449,7 +7090,7 @@ function branchWriteFailed(error, name) {
 }
 
 // src/apps/server/features/repository-refs/git/branches/branch-git.ts
-import { Effect as Effect45 } from "effect";
+import { Effect as Effect49 } from "effect";
 
 // src/apps/server/features/repository-refs/git/parse-for-each-ref.ts
 var forEachRefFormat = [
@@ -6530,7 +7171,12 @@ function tagFromRecord(record) {
   if (!record.name.startsWith(tagPrefix))
     return;
   let target = record.objectType === "commit" ? record.commit : record.peeledObjectType === "commit" ? record.peeledObject : void 0;
-  return target === void 0 ? void 0 : { name: record.name.slice(tagPrefix.length), target };
+  if (target !== void 0)
+    return {
+      name: record.name.slice(tagPrefix.length),
+      target,
+      ...record.objectType === "tag" ? { object: record.commit } : {}
+    };
 }
 function parseTracking(track) {
   return {
@@ -6553,20 +7199,20 @@ function requireValidBranchName(git, directory, name) {
     _tag: "InvalidBranchName",
     name
   };
-  return name.startsWith("-") || name === "HEAD" ? Effect45.fail(invalid) : requireValidRefName(git, directory, branchRef(name), invalid);
+  return name.startsWith("-") || name === "HEAD" ? Effect49.fail(invalid) : requireValidRefName(git, directory, branchRef(name), invalid);
 }
 function readBranchTarget(git, directory, name) {
   return readRefTarget(git, directory, `${branchRef(name)}^{commit}`);
 }
 function requireBranchTarget(git, directory, name, expectedTarget) {
   return readBranchTarget(git, directory, name).pipe(
-    Effect45.flatMap((target) => target === void 0 ? Effect45.fail({
+    Effect49.flatMap((target) => target === void 0 ? Effect49.fail({
       _tag: "RefMissing",
       name
-    }) : expectedTarget !== void 0 && target !== expectedTarget ? Effect45.fail({
+    }) : expectedTarget !== void 0 && target !== expectedTarget ? Effect49.fail({
       _tag: "BranchMoved",
       name
-    }) : Effect45.succeed(target))
+    }) : Effect49.succeed(target))
   );
 }
 function worktreeHolding(worktrees, name) {
@@ -6579,7 +7225,7 @@ function readLocalBranch(git, directory, worktrees, name) {
     ["for-each-ref", `--format=${forEachRefFormat}`, branchRef(name)],
     refCommand
   ).pipe(
-    Effect45.map((output) => {
+    Effect49.map((output) => {
       let record = parseForEachRef(output).find(
         (candidate) => candidate.name === branchRef(name)
       ), { worktreePath: _raw, ...branch } = (record === void 0 ? void 0 : localBranchFromRecord(record)) ?? { name }, holder = worktreeHolding(worktrees, name);
@@ -6602,19 +7248,19 @@ function requireRemoteBranch(git, directory, upstream) {
     ["rev-parse", "--verify", "--quiet", `refs/remotes/${name}`],
     refCommand
   ).pipe(
-    Effect45.mapError(
+    Effect49.mapError(
       (error) => isGitRejection(error) ? { _tag: "RefMissing", name } : branchWriteFailed(error, name)
     ),
-    Effect45.asVoid
+    Effect49.asVoid
   );
 }
 
 // src/apps/server/features/repository-refs/git/branches/delete-branch.ts
-import { Effect as Effect46 } from "effect";
+import { Effect as Effect50 } from "effect";
 var listedCommits = 20, pushCommand = { literalPathspecs: !1, timeoutMilliseconds: 12e4 };
 function deleteBranch(git, access, command) {
   let { force, local, remote, worktreePath } = command;
-  return Effect46.gen(function* () {
+  return Effect50.gen(function* () {
     return local !== void 0 && (yield* requireDeletableLocal(git, access, worktreePath, local)), remote !== void 0 && (yield* requireRemoteTarget(git, worktreePath, remote)), force || (yield* rejectUnmergedCommits(git, worktreePath, command)), remote !== void 0 && (yield* deleteRemote(git, worktreePath, remote)), local !== void 0 && (yield* deleteLocal(git, worktreePath, local)), {
       ...local === void 0 ? {} : { local },
       ...remote === void 0 ? {} : { remote }
@@ -6622,10 +7268,10 @@ function deleteBranch(git, access, command) {
   });
 }
 function requireDeletableLocal(git, access, worktreePath, { name, target }) {
-  return Effect46.gen(function* () {
+  return Effect50.gen(function* () {
     let holder = worktreeHolding(yield* access.worktrees(worktreePath), name);
     if (holder !== void 0)
-      return yield* Effect46.fail({
+      return yield* Effect50.fail({
         _tag: "BranchCheckedOutElsewhere",
         name,
         worktreePath: holder.path
@@ -6640,14 +7286,14 @@ function deleteLocal(git, directory, { name, target }) {
     ["update-ref", "-d", branchRef(name), target],
     refCommand
   ).pipe(
-    Effect46.catchIf(
+    Effect50.catchIf(
       isGitRejection,
-      () => Effect46.fail({
+      () => Effect50.fail({
         _tag: "BranchMoved",
         name
       })
     ),
-    Effect46.andThen(
+    Effect50.andThen(
       runRepositoryGit(
         git,
         directory,
@@ -6655,7 +7301,7 @@ function deleteLocal(git, directory, { name, target }) {
         { ...refCommand, exitCodes: [0, 1, 128] }
       )
     ),
-    Effect46.asVoid
+    Effect50.asVoid
   );
 }
 function requireRemoteTarget(git, directory, remote) {
@@ -6666,12 +7312,12 @@ function requireRemoteTarget(git, directory, remote) {
     ["rev-parse", "--verify", "--quiet", `refs/remotes/${name}^{commit}`],
     { ...refCommand, exitCodes: [0, 1] }
   ).pipe(
-    Effect46.flatMap((output) => {
+    Effect50.flatMap((output) => {
       let target = output.trim();
-      return target.length === 0 ? Effect46.fail({
+      return target.length === 0 ? Effect50.fail({
         _tag: "RefMissing",
         name
-      }) : target === remote.target ? Effect46.void : Effect46.fail({
+      }) : target === remote.target ? Effect50.void : Effect50.fail({
         _tag: "BranchMoved",
         name
       });
@@ -6690,7 +7336,7 @@ function rejectUnmergedCommits(git, directory, { local, remote }) {
     "--remotes",
     "--tags"
   ];
-  return Effect46.all(
+  return Effect50.all(
     {
       count: runRepositoryGit(
         git,
@@ -6712,9 +7358,9 @@ function rejectUnmergedCommits(git, directory, { local, remote }) {
     },
     { concurrency: "unbounded" }
   ).pipe(
-    Effect46.flatMap(({ count, log }) => {
+    Effect50.flatMap(({ count, log }) => {
       let unmerged = Number.parseInt(count.trim(), 10);
-      return unmerged === 0 ? Effect46.void : Effect46.fail({
+      return unmerged === 0 ? Effect50.void : Effect50.fail({
         _tag: "BranchNotMerged",
         commits: parseCommits(log),
         count: unmerged,
@@ -6736,8 +7382,8 @@ function deleteRemote(git, directory, remote) {
     ],
     pushCommand
   ).pipe(
-    Effect46.asVoid,
-    Effect46.mapError(
+    Effect50.asVoid,
+    Effect50.mapError(
       (error) => isGitRejection(error) && /stale info|fetch first/i.test(error.detail) ? { _tag: "BranchMoved", name: remoteLabel(remote) } : branchWriteFailed(error, remoteLabel(remote))
     )
   );
@@ -6757,10 +7403,10 @@ function isDefined(value) {
 }
 
 // src/apps/server/features/repository-refs/git/branches/rename-branch.ts
-import { Effect as Effect47 } from "effect";
+import { Effect as Effect51 } from "effect";
 function renameBranch(git, access, command) {
   let { name, newName, worktreePath } = command;
-  return Effect47.gen(function* () {
+  return Effect51.gen(function* () {
     yield* requireValidBranchName(git, worktreePath, newName);
     let before = yield* access.worktrees(worktreePath);
     yield* rejectHeldElsewhere(before, name, worktreePath), yield* requireRenameSource(git, command, before), yield* runRepositoryGit(
@@ -6768,17 +7414,17 @@ function renameBranch(git, access, command) {
       worktreePath,
       ["branch", "-m", name, newName],
       refCommand
-    ).pipe(Effect47.mapError((error) => branchWriteFailed(error, newName)));
+    ).pipe(Effect51.mapError((error) => branchWriteFailed(error, newName)));
     let after = yield* access.worktrees(worktreePath);
     return { branch: yield* readLocalBranch(git, worktreePath, after, newName), previousName: name };
   });
 }
 function requireRenameSource(git, { expectedTarget, name, worktreePath }, worktrees) {
   return readBranchTarget(git, worktreePath, name).pipe(
-    Effect47.flatMap((target) => target !== void 0 ? target === expectedTarget ? Effect47.void : Effect47.fail({
+    Effect51.flatMap((target) => target !== void 0 ? target === expectedTarget ? Effect51.void : Effect51.fail({
       _tag: "BranchMoved",
       name
-    }) : expectedTarget === void 0 && worktreeHolding(worktrees, name)?.path === worktreePath ? Effect47.void : Effect47.fail({
+    }) : expectedTarget === void 0 && worktreeHolding(worktrees, name)?.path === worktreePath ? Effect51.void : Effect51.fail({
       _tag: "RefMissing",
       name
     }))
@@ -6786,7 +7432,7 @@ function requireRenameSource(git, { expectedTarget, name, worktreePath }, worktr
 }
 function rejectHeldElsewhere(worktrees, name, worktreePath) {
   let holder = worktreeHolding(worktrees, name);
-  return holder === void 0 || holder.path === worktreePath ? Effect47.void : Effect47.fail({
+  return holder === void 0 || holder.path === worktreePath ? Effect51.void : Effect51.fail({
     _tag: "BranchCheckedOutElsewhere",
     name,
     worktreePath: holder.path
@@ -6795,13 +7441,13 @@ function rejectHeldElsewhere(worktrees, name, worktreePath) {
 
 // src/apps/server/features/repository-refs/git/checkout-repository-ref.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { Effect as Effect48 } from "effect";
+import { Effect as Effect52 } from "effect";
 var checkoutCommand = {
   literalPathspecs: !1,
   timeoutMilliseconds: 6e4
 };
 function checkoutRepositoryRef(git, access, command) {
-  return Effect48.gen(function* () {
+  return Effect52.gen(function* () {
     let worktrees = yield* access.worktrees(command.worktreePath), worktree = yield* requireWorktree(worktrees, command.worktreePath), target = yield* resolveTarget(git, worktree.path, command.target);
     if (yield* rejectBranchCheckedOutElsewhere(worktrees, worktree, target), target._tag === "LocalBranch" && worktree.head.branch === target.name)
       return {
@@ -6809,18 +7455,18 @@ function checkoutRepositoryRef(git, access, command) {
         stash: "none",
         worktreePath: worktree.path
       };
-    let stash = yield* Effect48.uninterruptible(
+    let stash = yield* Effect52.uninterruptible(
       checkoutWithAutoStash(git, worktree.path, target)
     );
     return { head: yield* readCheckedOutHead(access, worktree.path), stash, worktreePath: worktree.path };
   });
 }
 function checkoutWithAutoStash(git, directory, target) {
-  return Effect48.gen(function* () {
+  return Effect52.gen(function* () {
     let stash = yield* stashLocalChanges(git, directory, target);
     return stash === void 0 ? (yield* runCheckout(git, directory, target), "none") : (yield* runCheckout(git, directory, target).pipe(
-      Effect48.tapError(
-        () => restoreStash(git, directory, stash).pipe(Effect48.ignore)
+      Effect52.tapError(
+        () => restoreStash(git, directory, stash).pipe(Effect52.ignore)
       )
     ), (yield* restoreStash(git, directory, stash)) ? "restored" : "kept");
   });
@@ -6829,15 +7475,15 @@ function requireWorktree(worktrees, worktreePath) {
   let worktree = worktrees.find(
     (candidate) => candidate.path === worktreePath
   );
-  return worktree === void 0 ? Effect48.fail(
+  return worktree === void 0 ? Effect52.fail(
     repositoryRejected(
       "Missing",
       "This worktree does not belong to the repository."
     )
-  ) : Effect48.succeed(worktree);
+  ) : Effect52.succeed(worktree);
 }
 function resolveTarget(git, directory, target) {
-  return target._tag !== "RemoteBranch" ? Effect48.succeed(target) : Effect48.gen(function* () {
+  return target._tag !== "RemoteBranch" ? Effect52.succeed(target) : Effect52.gen(function* () {
     if (!(yield* gitAccepts(git, directory, [
       "show-ref",
       "--verify",
@@ -6850,8 +7496,8 @@ function resolveTarget(git, directory, target) {
       ["rev-parse", "--abbrev-ref", "--quiet", `${target.name}@{upstream}`],
       checkoutCommand
     ).pipe(
-      Effect48.map((upstream) => upstream.trim()),
-      Effect48.catchIf(isGitRejection, () => Effect48.succeed(""))
+      Effect52.map((upstream) => upstream.trim()),
+      Effect52.catchIf(isGitRejection, () => Effect52.succeed(""))
     );
     return tracked.length === 0 || tracked === `${target.remote}/${target.name}` ? { _tag: "LocalBranch", name: target.name } : {
       _tag: "DetachedRemoteBranch",
@@ -6861,25 +7507,25 @@ function resolveTarget(git, directory, target) {
   });
 }
 function rejectBranchCheckedOutElsewhere(worktrees, worktree, target) {
-  if (target._tag !== "LocalBranch") return Effect48.void;
+  if (target._tag !== "LocalBranch") return Effect52.void;
   let elsewhere = worktrees.find(
     (candidate) => candidate.path !== worktree.path && candidate.head.branch === target.name
   );
-  return elsewhere === void 0 ? Effect48.void : Effect48.fail({
+  return elsewhere === void 0 ? Effect52.void : Effect52.fail({
     _tag: "BranchCheckedOutElsewhere",
     name: target.name,
     worktreePath: elsewhere.path
   });
 }
 function stashLocalChanges(git, directory, target) {
-  return Effect48.gen(function* () {
+  return Effect52.gen(function* () {
     if ((yield* runRepositoryGit(
       git,
       directory,
       ["status", "--porcelain", "-z"],
       checkoutCommand
-    ).pipe(Effect48.mapError((error) => checkoutFailure(error, target.name)))).length === 0) return;
-    let token = `rebase-auto-stash:${randomUUID5()}`, stashFailure = yield* runRepositoryGit(
+    ).pipe(Effect52.mapError((error) => checkoutFailure(error, target.name)))).length === 0) return;
+    let token = `rebase-auto-stash:${randomUUID5()}`, stashed = yield* runRepositoryGit(
       git,
       directory,
       [
@@ -6891,12 +7537,11 @@ function stashLocalChanges(git, directory, target) {
       ],
       checkoutCommand
     ).pipe(
-      Effect48.as(""),
-      Effect48.catchIf(isGitRejection, (error) => Effect48.succeed(error.detail))
+      Effect52.as(!0),
+      Effect52.catchIf(isGitRejection, () => Effect52.succeed(!1))
     ), entry = yield* findStash(git, directory, token);
-    return stashFailure !== "" || entry === void 0 ? yield* Effect48.fail({
+    return !stashed || entry === void 0 ? yield* Effect52.fail({
       _tag: "CheckoutRejected",
-      detail: stashFailure,
       reason: "StashFailed"
     }) : token;
   });
@@ -6908,7 +7553,7 @@ function findStash(git, directory, token) {
     ["stash", "list", "--format=%H%x00%s"],
     checkoutCommand
   ).pipe(
-    Effect48.map((listed) => {
+    Effect52.map((listed) => {
       let lines = listed.split(`
 `), index2 = lines.findIndex(
         (line) => line.split("\0")[1]?.includes(token)
@@ -6924,8 +7569,8 @@ function runCheckout(git, directory, target) {
     checkoutArguments(target),
     checkoutCommand
   ).pipe(
-    Effect48.asVoid,
-    Effect48.mapError((error) => checkoutFailure(error, target.name))
+    Effect52.asVoid,
+    Effect52.mapError((error) => checkoutFailure(error, target.name))
   );
 }
 function checkoutArguments(target) {
@@ -6951,7 +7596,7 @@ function checkoutArguments(target) {
   }
 }
 function restoreStash(git, directory, token) {
-  return Effect48.gen(function* () {
+  return Effect52.gen(function* () {
     let entry = yield* findStash(git, directory, token);
     if (entry === void 0 || !(yield* gitAccepts(git, directory, [
       "stash",
@@ -6968,14 +7613,14 @@ function restoreStash(git, directory, token) {
 }
 function readCheckedOutHead(access, worktreePath) {
   return access.worktrees(worktreePath).pipe(
-    Effect48.flatMap((worktrees) => requireWorktree(worktrees, worktreePath)),
-    Effect48.map((worktree) => worktree.head)
+    Effect52.flatMap((worktrees) => requireWorktree(worktrees, worktreePath)),
+    Effect52.map((worktree) => worktree.head)
   );
 }
 function gitAccepts(git, directory, args) {
   return runRepositoryGit(git, directory, args, checkoutCommand).pipe(
-    Effect48.as(!0),
-    Effect48.catchIf(isGitRejection, () => Effect48.succeed(!1))
+    Effect52.as(!0),
+    Effect52.catchIf(isGitRejection, () => Effect52.succeed(!1))
   );
 }
 function checkoutFailure(error, targetName) {
@@ -6990,17 +7635,16 @@ function checkoutFailure(error, targetName) {
     error.detail
   ) ? { _tag: "RefMissing", name: targetName } : /would be overwritten by checkout/i.test(error.detail) ? {
     _tag: "CheckoutRejected",
-    detail: error.detail,
     reason: "LocalChanges"
   } : repositoryRejected("GitFailed", error.detail);
 }
 
 // src/apps/server/features/repository-refs/git/read-repository-refs.ts
-import { Effect as Effect49 } from "effect";
+import { Effect as Effect53 } from "effect";
 var readTimeoutMilliseconds = 15e3, maximumRefsOutputBytes2 = 16 * 1048576;
 function readRepositoryRefs(git, repository) {
-  return Effect49.gen(function* () {
-    let output = yield* Effect49.all(
+  return Effect53.gen(function* () {
+    let output = yield* Effect53.all(
       {
         branches: listRefs(
           git,
@@ -7051,7 +7695,7 @@ function listRefs(git, directory, pattern, sort) {
       maxOutputBytes: maximumRefsOutputBytes2,
       timeoutMilliseconds: readTimeoutMilliseconds
     }
-  ).pipe(Effect49.map(parseForEachRef));
+  ).pipe(Effect53.map(parseForEachRef));
 }
 function canonicalizeBranchWorktrees(branches, rawWorktrees, canonicalWorktrees) {
   let canonicalByRawPath = new Map(
@@ -7080,12 +7724,12 @@ function readRemoteMetadata(git, directory) {
     ["config", "--get-regexp", "^remote\\..*\\.url$"],
     { timeoutMilliseconds: 5e3, maxOutputBytes: 65536 }
   ).pipe(
-    Effect49.map((remotes) => ({
+    Effect53.map((remotes) => ({
       githubRepository: githubRepositoryFromRemotes(remotes),
       remoteProviders: remoteProvidersFromConfig(remotes)
     })),
-    Effect49.catch(
-      () => Effect49.succeed({ githubRepository: void 0, remoteProviders: [] })
+    Effect53.catch(
+      () => Effect53.succeed({ githubRepository: void 0, remoteProviders: [] })
     )
   );
 }
@@ -7146,88 +7790,165 @@ function fitRepositoryRefs(refs) {
 }
 
 // src/apps/server/features/repository-refs/git/repository-tags.ts
-import { Effect as Effect50 } from "effect";
-function createTag(git, { name, target, worktreePath }) {
-  return Effect50.gen(function* () {
-    return yield* requireValidTagName(git, worktreePath, name), yield* runRepositoryGit(
+import { Effect as Effect54 } from "effect";
+var pushCommand2 = { literalPathspecs: !1, timeoutMilliseconds: 12e4 };
+function createTag(git, { name, target, message, worktreePath }) {
+  return Effect54.gen(function* () {
+    if (yield* requireValidTagName(git, worktreePath, name), message === void 0)
+      return yield* requireUnsignedTagsAllowed(git, worktreePath), yield* runRepositoryGit(
+        git,
+        worktreePath,
+        ["tag", "--no-sign", name, target],
+        refCommand
+      ).pipe(Effect54.mapError(tagWriteFailed)), { name, target };
+    yield* runRepositoryGit(
       git,
       worktreePath,
-      ["tag", "--no-sign", name, target],
-      refCommand
-    ).pipe(Effect50.mapError(tagWriteFailed)), { name, target };
+      ["tag", "--annotate", "--file=-", name, target],
+      { ...refCommand, input: message }
+    ).pipe(Effect54.mapError(tagWriteFailed));
+    let object = yield* readRefTarget(git, worktreePath, tagRef(name));
+    return object === void 0 ? { name, target } : { name, target, object };
   });
 }
-function deleteTag(git, { name, worktreePath }) {
-  return Effect50.gen(function* () {
-    let target = yield* requireTagTarget(git, worktreePath, name);
-    return yield* runRepositoryGit(
+function deleteTag(git, { name, local, remote, worktreePath }) {
+  return Effect54.gen(function* () {
+    return local !== void 0 && (yield* requireTagObject(git, worktreePath, name)), remote !== void 0 && (yield* runRepositoryGit(
+      git,
+      worktreePath,
+      [
+        "push",
+        `--force-with-lease=${tagRef(name)}:${remote.object}`,
+        remote.remote,
+        "--delete",
+        tagRef(name)
+      ],
+      pushCommand2
+    ).pipe(
+      Effect54.catchIf(
+        (error) => isGitRejection(error) && /stale info/.test(error.detail),
+        () => Effect54.fail(tagRejected("RemoteDiffers"))
+      )
+    )), local !== void 0 && (yield* runRepositoryGit(
       git,
       worktreePath,
-      ["tag", "--delete", "--", name],
+      ["update-ref", "-d", tagRef(name), local.object],
       refCommand
-    ), { name, target };
+    ).pipe(
+      Effect54.catchIf(isGitRejection, () => Effect54.fail(tagRejected("Moved")))
+    )), { name };
   });
 }
+function readTagAnnotation(git, { name, worktreePath }) {
+  return runRepositoryGit(
+    git,
+    worktreePath,
+    [
+      "for-each-ref",
+      "--count=1",
+      "--sort=refname",
+      `--format=${[
+        "%(refname)",
+        "%(objecttype)",
+        "%(objectname)",
+        "%(*objectname)",
+        "%(taggername)",
+        "%(taggerdate:iso-strict)",
+        "%(contents:signature)",
+        "%(contents)"
+      ].join("%00")}`,
+      tagRef(name)
+    ],
+    refCommand
+  ).pipe(
+    Effect54.flatMap((output) => {
+      let record = output.replace(/\n$/, "").split("\0"), [refname, type, object, target, tagger = "", date = ""] = record, signature = record[6] ?? "", contents = record.slice(7).join("\0");
+      return refname !== tagRef(name) || type !== "tag" || object === void 0 || target === void 0 ? Effect54.fail({ _tag: "RefMissing", name }) : Effect54.succeed({
+        name,
+        object,
+        target,
+        tagger: { name: tagger.slice(0, 512), date: date.slice(0, 64) },
+        message: (contents.endsWith(signature) && signature.length > 0 ? contents.slice(0, -signature.length) : contents).trimEnd().slice(0, 65536),
+        signed: signature.length > 0
+      });
+    })
+  );
+}
 function requireValidTagName(git, directory, name) {
-  let invalid = { _tag: "TagRejected", reason: "InvalidName" };
-  return name.startsWith("-") ? Effect50.fail(invalid) : requireValidRefName(git, directory, tagRef(name), invalid);
+  let invalid = tagRejected("InvalidName");
+  return name.startsWith("-") ? Effect54.fail(invalid) : requireValidRefName(git, directory, tagRef(name), invalid);
 }
-function requireTagTarget(git, directory, name) {
-  return readRefTarget(git, directory, `${tagRef(name)}^{}`).pipe(
-    Effect50.flatMap(
-      (target) => target === void 0 ? Effect50.fail({ _tag: "RefMissing", name }) : Effect50.succeed(target)
+function requireUnsignedTagsAllowed(git, directory) {
+  return runRepositoryGit(
+    git,
+    directory,
+    ["config", "--type=bool", "--get", "tag.gpgSign"],
+    { ...refCommand, exitCodes: [0, 1] }
+  ).pipe(
+    Effect54.flatMap(
+      (value) => value.trim() === "true" ? Effect54.fail(tagRejected("MessageRequired")) : Effect54.void
+    )
+  );
+}
+function requireTagObject(git, directory, name) {
+  return readRefTarget(git, directory, tagRef(name)).pipe(
+    Effect54.flatMap(
+      (object) => object === void 0 ? Effect54.fail({ _tag: "RefMissing", name }) : Effect54.void
     )
   );
 }
 function tagRef(name) {
   return `refs/tags/${name}`;
 }
+function tagRejected(reason) {
+  return { _tag: "TagRejected", reason };
+}
 function tagWriteFailed(error) {
-  return isGitRejection(error) && /already exists/.test(error.detail) ? { _tag: "TagRejected", reason: "Exists" } : repositoryRejected("GitFailed", error.detail);
+  return isGitRejection(error) && /already exists/.test(error.detail) ? tagRejected("Exists") : repositoryRejected("GitFailed", error.detail);
 }
 
 // src/apps/server/features/repository-refs/repository-change-publisher.ts
-import { Effect as Effect51, Exit, Queue as Queue3, Scope, Semaphore as Semaphore2 } from "effect";
+import { Effect as Effect55, Exit, Queue as Queue3, Scope, Semaphore as Semaphore2 } from "effect";
 var maximumWatchedRepositories = 32;
 function acquireRepositoryChangePublisher(git, watcher, events) {
-  return Effect51.gen(function* () {
-    let scope = yield* Effect51.scope, mutex = yield* Semaphore2.make(1), watches = /* @__PURE__ */ new Map(), changed = /* @__PURE__ */ new Map(), pending = yield* Queue3.make({
+  return Effect55.gen(function* () {
+    let scope = yield* Effect55.scope, mutex = yield* Semaphore2.make(1), watches = /* @__PURE__ */ new Map(), changed = /* @__PURE__ */ new Map(), pending = yield* Queue3.make({
       capacity: 1,
       strategy: "dropping"
     }), closed = !1;
-    yield* Effect51.addFinalizer(
-      () => Effect51.sync(() => {
+    yield* Effect55.addFinalizer(
+      () => Effect55.sync(() => {
         closed = !0, watches.clear(), changed.clear();
       })
     ), yield* publishRepositoryChanges(pending, changed, events).pipe(
-      Effect51.forkScoped
+      Effect55.forkScoped
     );
-    let register = (repositoryId, directory) => Effect51.gen(function* () {
+    let register = (repositoryId, directory) => Effect55.gen(function* () {
       let oldest = watches.entries().next().value;
       watches.size >= maximumWatchedRepositories && oldest !== void 0 && (watches.delete(oldest[0]), yield* Scope.close(oldest[1], Exit.void));
       let owned = yield* Scope.fork(scope);
-      yield* Effect51.acquireRelease(
+      yield* Effect55.acquireRelease(
         watcher.watch(directory, (kind) => {
           changed.get(repositoryId) !== "Refs" && changed.set(repositoryId, kind), Queue3.offerUnsafe(pending, void 0);
         }),
-        (handle) => Effect51.sync(handle.close)
-      ).pipe(Effect51.provideService(Scope.Scope, owned)), watches.set(repositoryId, owned);
-    }).pipe(Effect51.uninterruptible);
+        (handle) => Effect55.sync(handle.close)
+      ).pipe(Effect55.provideService(Scope.Scope, owned)), watches.set(repositoryId, owned);
+    }).pipe(Effect55.uninterruptible);
     return {
-      watch: (repository) => Effect51.gen(function* () {
+      watch: (repository) => Effect55.gen(function* () {
         if (closed || watches.has(repository.id)) return;
         let directory = yield* readGitCommonDirectory(
           git,
           repository.path,
           { timeoutMilliseconds: 5e3 }
-        ).pipe(Effect51.catch(() => Effect51.succeed(void 0)));
+        ).pipe(Effect55.catch(() => Effect55.succeed(void 0)));
         closed || directory === void 0 || (yield* register(repository.id, directory));
       }).pipe(Semaphore2.withPermit(mutex))
     };
   });
 }
 function publishRepositoryChanges(pending, changed, events) {
-  return Effect51.gen(function* () {
+  return Effect55.gen(function* () {
     for (; ; ) {
       yield* Queue3.take(pending), yield* Queue3.clear(pending);
       let batch = [...changed];
@@ -7253,16 +7974,16 @@ var branchPolicy = {
   duringOperation: "proceed"
 };
 function repositoryRefsFeature(dependencies) {
-  return Effect52.gen(function* () {
-    let { access, git } = dependencies, { command } = repositoryRoutes(dependencies), changes = yield* acquireRepositoryChangePublisher(
+  return Effect56.gen(function* () {
+    let { access, git } = dependencies, { command, query } = repositoryRoutes(dependencies), changes = yield* acquireRepositoryChangePublisher(
       git,
       dependencies.watcher,
       dependencies.events
-    ), readRefs = (repositoryId) => Effect52.gen(function* () {
+    ), readRefs = (repositoryId) => Effect56.gen(function* () {
       let repository = yield* access.repository(repositoryId);
       return yield* changes.watch(repository), yield* readRepositoryRefs(git, repository);
     }).pipe(
-      Effect52.mapError(
+      Effect56.mapError(
         (error) => error._tag === "RepositoryRejected" ? error : repositoryRejected(
           "GitFailed",
           error._tag === "GitFailed" ? error.detail : "The repository catalog is unavailable."
@@ -7310,6 +8031,10 @@ function repositoryRefsFeature(dependencies) {
           RepositoryTagsApi.delete,
           tagPolicy,
           (input, git2) => deleteTag(git2, input)
+        ),
+        query(
+          RepositoryTagsApi.annotation,
+          (input, git2) => readTagAnnotation(git2, input)
         )
       ]
     };
@@ -7317,14 +8042,14 @@ function repositoryRefsFeature(dependencies) {
 }
 function createBranch(git, access, command) {
   let { name, startPoint, track, worktreePath } = command;
-  return Effect52.gen(function* () {
+  return Effect56.gen(function* () {
     yield* requireValidBranchName(git, worktreePath, name), track !== void 0 && (yield* requireRemoteBranch(git, worktreePath, track)), yield* runRepositoryGit(
       git,
       worktreePath,
       ["branch", "--no-track", name, startPoint],
       refCommand
     ).pipe(
-      Effect52.mapError(
+      Effect56.mapError(
         (error) => /not a valid object name/i.test(error.detail) ? { _tag: "RefMissing", name: startPoint } : branchWriteFailed(error, name)
       )
     ), track !== void 0 && (yield* runRepositoryGit(
@@ -7332,20 +8057,20 @@ function createBranch(git, access, command) {
       worktreePath,
       setUpstreamArguments(name, track),
       refCommand
-    ).pipe(Effect52.mapError((error) => branchWriteFailed(error, name))));
+    ).pipe(Effect56.mapError((error) => branchWriteFailed(error, name))));
     let worktrees = yield* access.worktrees(worktreePath);
     return yield* readLocalBranch(git, worktreePath, worktrees, name);
   });
 }
 function setBranchUpstream(git, access, command) {
   let { name, upstream, worktreePath } = command;
-  return Effect52.gen(function* () {
+  return Effect56.gen(function* () {
     yield* requireBranchTarget(git, worktreePath, name, void 0), upstream === null ? yield* unsetUpstream(git, worktreePath, name) : (yield* requireRemoteBranch(git, worktreePath, upstream), yield* runRepositoryGit(
       git,
       worktreePath,
       setUpstreamArguments(name, upstream),
       refCommand
-    ).pipe(Effect52.mapError((error) => branchWriteFailed(error, name))));
+    ).pipe(Effect56.mapError((error) => branchWriteFailed(error, name))));
     let worktrees = yield* access.worktrees(worktreePath);
     return yield* readLocalBranch(git, worktreePath, worktrees, name);
   });
@@ -7357,12 +8082,12 @@ function unsetUpstream(git, directory, name) {
     ["branch", "--unset-upstream", name],
     refCommand
   ).pipe(
-    Effect52.asVoid,
-    Effect52.catchIf(
+    Effect56.asVoid,
+    Effect56.catchIf(
       (error) => /has no upstream information/i.test(error.detail),
-      () => Effect52.void
+      () => Effect56.void
     ),
-    Effect52.mapError((error) => branchWriteFailed(error, name))
+    Effect56.mapError((error) => branchWriteFailed(error, name))
   );
 }
 
@@ -7370,13 +8095,13 @@ function unsetUpstream(git, directory, name) {
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { eq as eq3 } from "drizzle-orm";
 import { drizzle as drizzle2 } from "drizzle-orm/node-sqlite";
-import { Effect as Effect56, Semaphore as Semaphore3 } from "effect";
+import { Effect as Effect60, Semaphore as Semaphore3 } from "effect";
 
 // src/apps/server/persistence/sqlite/database.ts
 import { chmodSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
 import { drizzle } from "drizzle-orm/node-sqlite";
-import { Effect as Effect53, Schedule } from "effect";
+import { Effect as Effect57, Schedule } from "effect";
 
 // src/apps/server/persistence/sqlite/migrations.ts
 import { existsSync } from "node:fs";
@@ -7436,7 +8161,7 @@ function resolveMigrationsFolder() {
 // src/apps/server/persistence/sqlite/database.ts
 var busyTimeoutMilliseconds = 1e3, databaseLockRetryDelay = "10 millis", databaseLockRetryCount = 10;
 function openEnvironmentDatabase(paths) {
-  return Effect53.gen(function* () {
+  return Effect57.gen(function* () {
     let database = yield* storageSync(
       "Could not open Environment state",
       () => new DatabaseSync(paths.stateDatabase, {
@@ -7445,7 +8170,7 @@ function openEnvironmentDatabase(paths) {
         timeout: busyTimeoutMilliseconds
       })
     );
-    return yield* Effect53.gen(function* () {
+    return yield* Effect57.gen(function* () {
       return yield* storageSync(
         "Could not open Environment state",
         () => configureDatabase(database)
@@ -7453,11 +8178,11 @@ function openEnvironmentDatabase(paths) {
         "Could not open Environment state",
         () => restrictDatabasePermissions(paths.stateDatabase)
       ), database;
-    }).pipe(Effect53.onError(() => closeEnvironmentDatabase(database)));
+    }).pipe(Effect57.onError(() => closeEnvironmentDatabase(database)));
   });
 }
 function closeEnvironmentDatabase(database) {
-  return Effect53.sync(() => database.close()).pipe(Effect53.orDie);
+  return Effect57.sync(() => database.close()).pipe(Effect57.orDie);
 }
 function configureDatabase(database) {
   database.exec(`
@@ -7473,7 +8198,7 @@ function migrateDatabase(database) {
 }
 function retryDatabaseLock(effect) {
   return effect.pipe(
-    Effect53.retry({
+    Effect57.retry({
       schedule: Schedule.spaced(databaseLockRetryDelay),
       times: databaseLockRetryCount,
       while: isDatabaseLocked
@@ -7499,19 +8224,19 @@ function restrictDatabasePermissions(path) {
 
 // src/apps/server/persistence/storage/environment-paths.ts
 import { chmod, mkdir as mkdir2 } from "node:fs/promises";
-import { join as join8 } from "node:path";
-import { Effect as Effect54 } from "effect";
+import { join as join9 } from "node:path";
+import { Effect as Effect58 } from "effect";
 function environmentPaths(root) {
-  let cacheDirectory = join8(root, "cache"), runtimeDirectory = join8(root, "runtime"), secretsDirectory = join8(root, "secrets"), settingsDirectory = join8(root, "settings"), stateDirectory = join8(root, "state");
+  let cacheDirectory = join9(root, "cache"), runtimeDirectory = join9(root, "runtime"), secretsDirectory = join9(root, "secrets"), settingsDirectory = join9(root, "settings"), stateDirectory = join9(root, "state");
   return {
     cacheDirectory,
     root,
     runtimeDirectory,
-    runtimeMarker: join8(runtimeDirectory, "runtime.json"),
+    runtimeMarker: join9(runtimeDirectory, "runtime.json"),
     secretsDirectory,
-    serverSecret: join8(secretsDirectory, "server.key"),
+    serverSecret: join9(secretsDirectory, "server.key"),
     settingsDirectory,
-    stateDatabase: join8(stateDirectory, "state.sqlite"),
+    stateDatabase: join9(stateDirectory, "state.sqlite"),
     stateDirectory
   };
 }
@@ -7524,7 +8249,7 @@ function prepareEnvironmentDirectories(paths) {
     paths.secretsDirectory,
     paths.cacheDirectory
   ];
-  return Effect54.tryPromise({
+  return Effect58.tryPromise({
     try: async () => {
       for (let directory of directories)
         await mkdir2(directory, { mode: 448, recursive: !0 }), process.platform !== "win32" && await chmod(directory, 448);
@@ -7542,14 +8267,14 @@ import {
   chmod as chmod2,
   link,
   mkdtemp as mkdtemp2,
-  readFile as readFile4,
+  readFile as readFile5,
   rm as rm4,
   writeFile as writeFile4
 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-import { Effect as Effect55 } from "effect";
+import { join as join10 } from "node:path";
+import { Effect as Effect59 } from "effect";
 function ensureServerSecret(paths) {
-  return Effect55.tryPromise({
+  return Effect59.tryPromise({
     try: () => readOrCreateServerSecret(paths.serverSecret),
     catch: (cause) => new EnvironmentStorageError({
       cause,
@@ -7560,7 +8285,7 @@ function ensureServerSecret(paths) {
 async function readOrCreateServerSecret(path) {
   let secret;
   try {
-    secret = await readFile4(path, "utf8");
+    secret = await readFile5(path, "utf8");
   } catch (error) {
     if (!isMissingFile2(error))
       throw error;
@@ -7571,7 +8296,7 @@ async function readOrCreateServerSecret(path) {
   return process.platform !== "win32" && await chmod2(path, 384), secret.trim();
 }
 async function publishServerSecret(path) {
-  let directory = await mkdtemp2(`${path}.`), temporaryPath = join9(directory, "key"), generated = `${randomBytes2(32).toString("base64url")}
+  let directory = await mkdtemp2(`${path}.`), temporaryPath = join10(directory, "key"), generated = `${randomBytes2(32).toString("base64url")}
 `;
   try {
     await writeFile4(temporaryPath, generated, { flag: "wx", mode: 384 });
@@ -7579,7 +8304,7 @@ async function publishServerSecret(path) {
       return await link(temporaryPath, path), generated;
     } catch (error) {
       if (!isExistingFile(error)) throw error;
-      return await readFile4(path, "utf8");
+      return await readFile5(path, "utf8");
     }
   } finally {
     await rm4(directory, { recursive: !0, force: !0 });
@@ -7594,9 +8319,9 @@ function isExistingFile(error) {
 
 // src/apps/server/persistence/environment-context.ts
 function acquireEnvironmentContext(paths) {
-  return Effect56.gen(function* () {
+  return Effect60.gen(function* () {
     yield* prepareEnvironmentDirectories(paths);
-    let serverSecret = yield* ensureServerSecret(paths), database = yield* Effect56.acquireRelease(
+    let serverSecret = yield* ensureServerSecret(paths), database = yield* Effect60.acquireRelease(
       openEnvironmentDatabase(paths),
       closeEnvironmentDatabase
     ), context = yield* storageSync(
@@ -7627,19 +8352,20 @@ function initializeEnvironment(context) {
 
 // src/apps/server/repository/repository-coordination.ts
 import { realpath as realpath5 } from "node:fs/promises";
-import { Effect as Effect58, Option as Option2, Semaphore as Semaphore4 } from "effect";
+import { Effect as Effect62, Option as Option2, Semaphore as Semaphore4 } from "effect";
 
 // src/apps/server/repository/repository-operation.ts
 import { createHash as createHash4 } from "node:crypto";
-import { lstat as lstat3, readFile as readFile5, stat as stat5 } from "node:fs/promises";
-import { join as join10 } from "node:path";
-import { Effect as Effect57 } from "effect";
+import { lstat as lstat3, readFile as readFile6, stat as stat5 } from "node:fs/promises";
+import { join as join11 } from "node:path";
+import { Effect as Effect61 } from "effect";
 var maximumMetadataBytes = 2 * 1024 * 1024, metadataNames = [
   "HEAD",
   "MERGE_HEAD",
   "CHERRY_PICK_HEAD",
   "REVERT_HEAD",
   "MERGE_MSG",
+  "SQUASH_MSG",
   "AUTO_MERGE",
   "rebase-merge/head-name",
   "rebase-merge/onto",
@@ -7668,23 +8394,23 @@ var maximumMetadataBytes = 2 * 1024 * 1024, metadataNames = [
   worktree: []
 };
 function readRepositoryOperation(git, worktreePath, directories) {
-  return Effect57.gen(function* () {
+  return Effect61.gen(function* () {
     let { values, metadata, stamps } = yield* readOperationMetadata(
       directories.gitDirectory
-    ), lock = yield* readGitLock(directories), kind = identifyOperation(metadata, stamps), worktree = kind === "idle" ? idleWorktree : yield* inspectWorktree(git, worktreePath, directories.gitDirectory), unresolvedPaths = [
+    ), lock = yield* readGitLock(directories), candidate = identifyOperation(metadata, stamps), worktree = candidate === "idle" ? idleWorktree : yield* inspectWorktree(git, worktreePath, directories.gitDirectory), unresolvedPaths = [
       ...new Set(
         worktree.unresolved.split("\0").filter(Boolean).map((line) => line.slice(line.indexOf("	") + 1))
       )
-    ].sort(), edit = kind === "rebase" && metadata["rebase-merge/amend"] !== null && unresolvedPaths.length === 0, reason = blockedReason(
+    ].sort(), kind = candidate === "squash" && unresolvedPaths.length === 0 ? "idle" : candidate, edit = kind === "rebase" && metadata["rebase-merge/amend"] !== null && unresolvedPaths.length === 0, empty = unresolvedPaths.length === 0 && (metadata.CHERRY_PICK_HEAD ?? metadata.REVERT_HEAD) !== null && !hasStagedChanges2(worktree.status), reason = empty ? lockedReason(lock) ?? "Nothing to commit. Skip this commit." : blockedReason(
       kind,
       lock,
       unresolvedPaths.length,
       edit,
       worktree.status
-    );
+    ), steps = kind === "rebase" ? rebaseSteps(metadata) : null, progress = stepProgress(steps) ?? operationProgress(metadata) ?? (yield* sequenceProgress(git, worktreePath, metadata, worktree.head));
     return {
       kind,
-      phase: operationPhase(kind, unresolvedPaths.length, edit),
+      phase: empty ? "empty" : operationPhase(kind, unresolvedPaths.length, edit),
       actions: availableActions(kind, metadata, stamps, edit, lock, reason),
       unresolvedPaths,
       lock,
@@ -7693,21 +8419,22 @@ function readRepositoryOperation(git, worktreePath, directories) {
         metadata["rebase-merge/head-name"] ?? metadata["rebase-apply/head-name"] ?? metadata.HEAD
       ),
       commit: (kind === "merge" ? metadata.MERGE_HEAD?.split(`
-`)[0] : metadata["rebase-merge/stopped-sha"] ?? metadata["rebase-apply/original-commit"] ?? metadata.CHERRY_PICK_HEAD ?? metadata.REVERT_HEAD)?.trim() ?? null,
+`)[0] : kind === "squash" ? /^commit ([0-9a-f]+)$/m.exec(metadata.SQUASH_MSG ?? "")?.[1] : metadata["rebase-merge/stopped-sha"] ?? metadata["rebase-apply/original-commit"] ?? metadata.CHERRY_PICK_HEAD ?? metadata.REVERT_HEAD)?.trim() ?? null,
       mergedBranch: kind === "merge" ? mergedBranchName(metadata.MERGE_MSG) : null,
-      progress: operationProgress(metadata)
+      progress,
+      steps
     };
   });
 }
 function readOperationMetadata(gitDirectory) {
-  return Effect57.gen(function* () {
-    let values = yield* Effect57.forEach(
+  return Effect61.gen(function* () {
+    let values = yield* Effect61.forEach(
       metadataNames,
       (name) => readOperationFile(gitDirectory, name),
       { concurrency: 8 }
     ), metadata = Object.fromEntries(
       metadataNames.map((name, index2) => [name, values[index2] ?? null])
-    ), stamps = yield* Effect57.forEach(
+    ), stamps = yield* Effect61.forEach(
       ["rebase-merge", "rebase-apply", "sequencer"],
       (name) => operationFileStamp(gitDirectory, name)
     );
@@ -7715,7 +8442,7 @@ function readOperationMetadata(gitDirectory) {
   });
 }
 function readGitLock({ gitDirectory, commonDirectory }) {
-  return Effect57.gen(function* () {
+  return Effect61.gen(function* () {
     return (yield* operationFileStamp(gitDirectory, "index.lock")) !== null ? "index.lock" : (yield* operationFileStamp(commonDirectory, "packed-refs.lock")) !== null ? "packed-refs.lock" : null;
   });
 }
@@ -7723,13 +8450,13 @@ function operationPhase(kind, unresolved, edit) {
   return kind === "idle" ? "idle" : kind === "unknown" ? "blocked" : unresolved ? "conflicts" : edit ? "edit" : "ready";
 }
 function inspectWorktree(git, worktreePath, gitDirectory) {
-  return Effect57.gen(function* () {
+  return Effect61.gen(function* () {
     let head = yield* inspect(
       git,
       worktreePath,
       ["rev-parse", "--verify", "--quiet", "HEAD"],
       [0, 1]
-    ).pipe(Effect57.map((output) => output.trim() || null)), index2 = yield* operationFileStamp(gitDirectory, "index"), unresolved = yield* inspect(git, worktreePath, [
+    ).pipe(Effect61.map((output) => output.trim() || null)), index2 = yield* operationFileStamp(gitDirectory, "index"), unresolved = yield* inspect(git, worktreePath, [
       "ls-files",
       "--unmerged",
       "-z"
@@ -7739,7 +8466,7 @@ function inspectWorktree(git, worktreePath, gitDirectory) {
       "--no-renames",
       "-z",
       "--untracked-files=no"
-    ]), worktree = yield* Effect57.forEach(
+    ]), worktree = yield* Effect61.forEach(
       status.split("\0").filter(Boolean),
       (record) => operationFileStamp(worktreePath, record.slice(3)),
       { concurrency: 16 }
@@ -7753,7 +8480,7 @@ function inspect(git, worktreePath, args, exitCodes) {
     worktreePath,
     args,
     exitCodes === void 0 ? {} : { exitCodes }
-  ).pipe(Effect57.mapError((error) => inspectionFailed(error.detail)));
+  ).pipe(Effect61.mapError((error) => inspectionFailed(error.detail)));
 }
 function identifyOperation(metadata, stamps) {
   if (stamps[0] !== null) return "rebase";
@@ -7763,11 +8490,14 @@ function identifyOperation(metadata, stamps) {
   if (metadata.CHERRY_PICK_HEAD !== null) return "cherry-pick";
   if (metadata.REVERT_HEAD !== null) return "revert";
   let todo = metadata["sequencer/todo"]?.trimStart();
-  return todo?.startsWith("pick ") ? "cherry-pick" : todo?.startsWith("revert ") ? "revert" : stamps[2] === null ? "idle" : "unknown";
+  return todo?.startsWith("pick ") ? "cherry-pick" : todo?.startsWith("revert ") ? "revert" : stamps[2] !== null ? "unknown" : metadata.SQUASH_MSG === null ? "idle" : "squash";
+}
+function lockedReason(lock) {
+  return lock === null ? null : "Git is using this worktree. Check again when it finishes.";
 }
 function blockedReason(kind, lock, unresolved, edit, status) {
-  if (lock !== null)
-    return "Git is using this worktree. Check again when it finishes.";
+  let locked = lockedReason(lock);
+  if (locked !== null) return locked;
   if (unresolved)
     return `Resolve and stage ${unresolved} ${unresolved === 1 ? "file" : "files"} to continue.`;
   if (edit && status.length > 0)
@@ -7780,7 +8510,9 @@ function availableActions(kind, metadata, stamps, edit, lock, reason) {
   let unlocked = {
     enabled: lock === null,
     reason: lock === null ? null : reason
-  }, skippable = kind !== "merge" && !edit && (kind !== "rebase" || metadata["rebase-merge/stopped-sha"] !== null || stamps[1] !== null);
+  };
+  if (kind === "squash") return [{ action: "abort", ...unlocked }];
+  let skippable = kind !== "merge" && !edit && !/no-commit\s*=\s*true/.test(metadata["sequencer/opts"] ?? "") && (kind !== "rebase" || metadata["rebase-merge/stopped-sha"] !== null || stamps[1] !== null);
   return [
     { action: "continue", enabled: reason === null, reason },
     ...skippable ? [{ action: "skip", ...unlocked }] : [],
@@ -7793,6 +8525,45 @@ function branchName(headName) {
 function mergedBranchName(message) {
   return /^Merge (?:remote-tracking )?branch '([^']+)'/.exec(message ?? "")?.[1] ?? null;
 }
+var planActions = {
+  pick: "pick",
+  p: "pick",
+  reword: "reword",
+  r: "reword",
+  edit: "edit",
+  e: "edit",
+  squash: "squash",
+  s: "squash",
+  fixup: "fixup",
+  f: "fixup",
+  drop: "drop",
+  d: "drop"
+};
+function rebaseSteps(metadata) {
+  let steps = [];
+  for (let [text3, done] of [
+    [metadata["rebase-merge/done"], !0],
+    [metadata["rebase-merge/git-rebase-todo"], !1]
+  ])
+    for (let line of (text3 ?? "").split(`
+`)) {
+      let trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#")) continue;
+      let match = /^(\w+)\s+([0-9a-f]{40,64})(?:\s+(.*))?$/.exec(trimmed), action = match?.[1] === void 0 ? void 0 : planActions[match[1]];
+      if (match === null || action === void 0) return null;
+      steps.push({
+        commit: match[2] ?? "",
+        action,
+        subject: (match[3] ?? "").replace(/^#\s*/, ""),
+        done
+      });
+    }
+  return steps.length === 0 ? null : steps;
+}
+function stepProgress(steps) {
+  let current = steps?.filter((step) => step.done).length ?? 0;
+  return steps === null || current === 0 ? null : { current, total: steps.length };
+}
 function operationProgress(metadata) {
   let current = Number(
     metadata["rebase-merge/msgnum"] ?? metadata["rebase-apply/next"]
@@ -7801,14 +8572,31 @@ function operationProgress(metadata) {
   );
   return Number.isSafeInteger(current) && Number.isSafeInteger(total) && current > 0 && total >= current ? { current, total } : null;
 }
+function hasStagedChanges2(status) {
+  return status.split("\0").some((line) => line.length > 2 && line[0] !== " " && line[0] !== "?");
+}
+function sequenceProgress(git, worktreePath, metadata, head) {
+  let start = metadata["sequencer/head"]?.trim(), remaining = (metadata["sequencer/todo"] ?? "").split(`
+`).filter((line) => /^(pick|revert|p|r)\s/.test(line)).length;
+  return start === void 0 || head === null || remaining === 0 || /no-commit\s*=\s*true/.test(metadata["sequencer/opts"] ?? "") ? Effect61.succeed(null) : inspect(git, worktreePath, [
+    "rev-list",
+    "--count",
+    `${start}..${head}`
+  ]).pipe(
+    Effect61.map((output) => {
+      let done = Number(output.trim());
+      return Number.isSafeInteger(done) ? { current: done + 1, total: done + remaining } : null;
+    })
+  );
+}
 function readOperationFile(directory, name) {
-  return Effect57.tryPromise({
+  return Effect61.tryPromise({
     try: async () => {
       try {
-        let path = join10(directory, name);
+        let path = join11(directory, name);
         if ((await stat5(path)).size > maximumMetadataBytes)
           throw new Error("Operation metadata is too large.");
-        return await readFile5(path, "utf8");
+        return await readFile6(path, "utf8");
       } catch (error) {
         if (isMissing(error)) return null;
         throw error;
@@ -7818,10 +8606,10 @@ function readOperationFile(directory, name) {
   });
 }
 function operationFileStamp(directory, name) {
-  return Effect57.tryPromise({
+  return Effect61.tryPromise({
     try: async () => {
       try {
-        let info = await lstat3(join10(directory, name), { bigint: !0 });
+        let info = await lstat3(join11(directory, name), { bigint: !0 });
         return `${info.ino}:${info.size}:${info.mtimeNs}:${info.ctimeNs}`;
       } catch (error) {
         if (isMissing(error)) return null;
@@ -7840,16 +8628,16 @@ function isMissing(error) {
 
 // src/apps/server/repository/repository-coordination.ts
 function createRepositoryCoordination(git) {
-  let locks = /* @__PURE__ */ new Map(), withLock = (key, acquisition, operation) => Effect58.acquireUseRelease(
-    Effect58.sync(() => {
+  let locks = /* @__PURE__ */ new Map(), withLock = (key, acquisition, operation) => Effect62.acquireUseRelease(
+    Effect62.sync(() => {
       let entry = locks.get(key);
       return entry === void 0 && (entry = { semaphore: Semaphore4.makeUnsafe(1), owners: 0 }, locks.set(key, entry)), entry.owners++, entry;
     }),
     (entry) => acquisition === "wait" ? entry.semaphore.withPermit(operation) : entry.semaphore.withPermitsIfAvailable(1)(operation).pipe(
-      Effect58.flatMap(
+      Effect62.flatMap(
         Option2.match({
-          onSome: Effect58.succeed,
-          onNone: () => Effect58.fail(
+          onSome: Effect62.succeed,
+          onNone: () => Effect62.fail(
             repositoryRejected(
               "Busy",
               "Another repository write is in progress."
@@ -7858,35 +8646,35 @@ function createRepositoryCoordination(git) {
         })
       )
     ),
-    (entry) => Effect58.sync(() => {
+    (entry) => Effect62.sync(() => {
       --entry.owners === 0 && locks.delete(key);
     })
-  ), directories = /* @__PURE__ */ new Map(), gitDirectories = (directory) => Effect58.gen(function* () {
+  ), directories = /* @__PURE__ */ new Map(), gitDirectories = (directory) => Effect62.gen(function* () {
     let identity = yield* readGitEntryIdentity(directory), cached = directories.get(directory);
     if (identity !== void 0 && cached?.identity === identity)
       return cached.paths;
     let paths = yield* resolveGitDirectories(git, directory);
     return identity !== void 0 && directories.set(directory, { identity, paths }), paths;
   }), forgetOnError = (directory, effect) => effect.pipe(
-    Effect58.onError(() => Effect58.sync(() => directories.delete(directory)))
+    Effect62.onError(() => Effect62.sync(() => directories.delete(directory)))
   );
   return {
     run: (directory, policy, operation) => forgetOnError(
       directory,
-      Effect58.gen(function* () {
+      Effect62.gen(function* () {
         let { refs, worktree } = policy.locks, paths = yield* gitDirectories(directory), guarded = requireCompatibleWrite(
           git,
           directory,
           paths,
           policy
-        ).pipe(Effect58.andThen(operation)), inWorktree = worktree === void 0 ? guarded : withLock(`worktree:${paths.gitDirectory}`, worktree, guarded);
+        ).pipe(Effect62.andThen(operation)), inWorktree = worktree === void 0 ? guarded : withLock(`worktree:${paths.gitDirectory}`, worktree, guarded);
         return yield* refs === void 0 ? inWorktree : withLock(`refs:${paths.commonDirectory}`, refs, inWorktree);
       })
     ),
     operation: (directory) => forgetOnError(
       directory,
       gitDirectories(directory).pipe(
-        Effect58.flatMap(
+        Effect62.flatMap(
           (paths) => readRepositoryOperation(git, directory, paths)
         )
       )
@@ -7894,10 +8682,10 @@ function createRepositoryCoordination(git) {
   };
 }
 function requireCompatibleWrite(git, directory, paths, { name, duringOperation }) {
-  return duringOperation === "proceed" ? Effect58.void : readRepositoryOperation(git, directory, paths).pipe(
-    Effect58.flatMap((state) => state.lock !== null ? Effect58.fail(
+  return duringOperation === "proceed" ? Effect62.void : readRepositoryOperation(git, directory, paths).pipe(
+    Effect62.flatMap((state) => state.lock !== null ? Effect62.fail(
       repositoryRejected("Busy", `Git lock exists: ${state.lock}.`)
-    ) : state.kind === "idle" || duringOperation !== "block" && duringOperation.allowWhen(state) ? Effect58.void : Effect58.fail(
+    ) : state.kind === "idle" || duringOperation !== "block" && duringOperation.allowWhen(state) ? Effect62.void : Effect62.fail(
       repositoryRejected(
         "Incompatible",
         `Cannot ${name} while ${state.kind === "unknown" ? "an unrecognized Git operation is" : `${state.kind} is`} in progress.`
@@ -7906,12 +8694,12 @@ function requireCompatibleWrite(git, directory, paths, { name, duringOperation }
   );
 }
 function resolveGitDirectories(git, directory) {
-  return Effect58.gen(function* () {
+  return Effect62.gen(function* () {
     let gitDirectory = (yield* runRepositoryGit(git, directory, [
       "rev-parse",
       "--absolute-git-dir"
     ])).trimEnd(), commonDirectory = yield* readGitCommonDirectory(git, directory);
-    return yield* Effect58.tryPromise({
+    return yield* Effect62.tryPromise({
       try: async () => ({
         gitDirectory: await realpath5(gitDirectory),
         commonDirectory: await realpath5(commonDirectory)
@@ -7922,7 +8710,7 @@ function resolveGitDirectories(git, directory) {
       )
     });
   }).pipe(
-    Effect58.mapError(
+    Effect62.mapError(
       (error) => error._tag === "GitFailed" ? repositoryRejected("GitFailed", error.detail) : error
     )
   );
@@ -7930,7 +8718,7 @@ function resolveGitDirectories(git, directory) {
 
 // src/apps/server/app/server/serve-environment.ts
 function serveEnvironment(dependencies, options) {
-  return Effect59.gen(function* () {
+  return Effect63.gen(function* () {
     let environment = yield* readCurrentEnvironment(dependencies.context), useAutomaticPort = options.port === void 0 || options.port === 0, listener = yield* acquireEnvironmentListener({
       authorization: dependencies.authorization,
       ...options.browserAssetsRoot === void 0 ? {} : { browserAssetsRoot: options.browserAssetsRoot },
@@ -7956,8 +8744,8 @@ function serveEnvironment(dependencies, options) {
   });
 }
 function acquireEnvironment(home, git) {
-  return Effect59.gen(function* () {
-    let paths = environmentPaths(join11(home, ".rebase")), context = yield* acquireEnvironmentContext(paths), watcher = createLocalRepositoryWatcher(), catalog = createRepositoryCatalog(context, git);
+  return Effect63.gen(function* () {
+    let paths = environmentPaths(join12(home, ".rebase")), context = yield* acquireEnvironmentContext(paths), watcher = createLocalRepositoryWatcher(), catalog = createRepositoryCatalog(context, git);
     return {
       access: createRepositoryAccess(catalog, git, watcher),
       authorization: createEnvironmentAuthorization(context),
@@ -7972,7 +8760,7 @@ function acquireEnvironment(home, git) {
   });
 }
 function environmentFeatures(dependencies) {
-  return Effect59.gen(function* () {
+  return Effect63.gen(function* () {
     return combineEnvironmentFeatures([
       environmentAuthorizationFeature(dependencies.authorization),
       environmentFilesystemFeature(),
@@ -8030,7 +8818,7 @@ function hasNoAutomaticPort() {
 
 // src/apps/server/app/server/start-environment-server.ts
 function startEnvironmentServer(options) {
-  return Effect60.gen(function* () {
+  return Effect64.gen(function* () {
     return yield* verifyRuntimeRequirements, yield* serveEnvironment(
       yield* acquireEnvironment(options.home, createLocalGitCommandRunner()),
       options
@@ -8042,20 +8830,20 @@ function startEnvironmentServer(options) {
 var usage = "Usage: rebase [serve] [--host <ip-address|lan|tailscale>] [--port <1-65535>]";
 function runCli(arguments_ = process.argv.slice(2)) {
   if (arguments_.includes("--help") || arguments_.includes("-h"))
-    return writeOutput(usage).pipe(Effect61.as(0));
+    return writeOutput(usage).pipe(Effect65.as(0));
   if (arguments_.includes("--version") || arguments_.includes("-v"))
-    return writeOutput(versionOutput()).pipe(Effect61.as(0));
-  let program = Effect61.try({
+    return writeOutput(versionOutput()).pipe(Effect65.as(0));
+  let program = Effect65.try({
     try: () => parseServeArguments(arguments_),
     catch: normalizeError
-  }).pipe(Effect61.flatMap(serve));
-  return Effect61.matchEffect(program, {
-    onFailure: (error) => writeFailure(`rebase serve failed: ${error.message}`).pipe(Effect61.as(1)),
-    onSuccess: () => Effect61.succeed(0)
+  }).pipe(Effect65.flatMap(serve));
+  return Effect65.matchEffect(program, {
+    onFailure: (error) => writeFailure(`rebase serve failed: ${error.message}`).pipe(Effect65.as(1)),
+    onSuccess: () => Effect65.succeed(0)
   });
 }
 async function main() {
-  process.exitCode = await Effect61.runPromise(runCli());
+  process.exitCode = await Effect65.runPromise(runCli());
 }
 function parseServeArguments(arguments_) {
   let normalizedArguments = arguments_.length === 0 || arguments_[0]?.startsWith("--") ? ["serve", ...arguments_] : arguments_, [command, ...options] = normalizedArguments;
@@ -8083,13 +8871,13 @@ function parsePort(value) {
   return port;
 }
 function serve(options) {
-  return Effect61.scoped(
-    Effect61.gen(function* () {
-      let shutdown = yield* acquireShutdownSignal(), server = yield* Effect61.raceFirst(
+  return Effect65.scoped(
+    Effect65.gen(function* () {
+      let shutdown = yield* acquireShutdownSignal(), server = yield* Effect65.raceFirst(
         startEnvironmentServer(options),
         Deferred3.await(shutdown)
       );
-      server !== void 0 && (yield* Effect61.sync(() => {
+      server !== void 0 && (yield* Effect65.sync(() => {
         process.stdout.write(`Listening URL: ${server.origin}
 `), process.stdout.write(`Pairing URL: ${server.pairingUrl}
 `), openDefaultBrowser(server.pairingUrl);
@@ -8098,29 +8886,29 @@ function serve(options) {
   );
 }
 function acquireShutdownSignal() {
-  return Effect61.gen(function* () {
+  return Effect65.gen(function* () {
     let shutdown = yield* Deferred3.make();
-    return yield* Effect61.acquireRelease(
-      Effect61.sync(() => {
+    return yield* Effect65.acquireRelease(
+      Effect65.sync(() => {
         let stop = () => {
-          Deferred3.doneUnsafe(shutdown, Effect61.void);
+          Deferred3.doneUnsafe(shutdown, Effect65.void);
         };
         return process.once("SIGINT", stop), process.once("SIGTERM", stop), stop;
       }),
-      (stop) => Effect61.sync(() => {
+      (stop) => Effect65.sync(() => {
         process.off("SIGINT", stop), process.off("SIGTERM", stop);
       })
     ), shutdown;
   });
 }
 function writeOutput(line) {
-  return Effect61.sync(() => {
+  return Effect65.sync(() => {
     process.stdout.write(`${line}
 `);
   });
 }
 function writeFailure(line) {
-  return Effect61.sync(() => {
+  return Effect65.sync(() => {
     process.stderr.write(`${line}
 `);
   });
@@ -8140,7 +8928,7 @@ function resolveBrowserAssetsRoot() {
   return fileURLToPath2(root);
 }
 function productVersion() {
-  return "0.0.2-nightly.20260928.132";
+  return "0.0.2";
 }
 function versionOutput() {
   return [