@cvr/stacked 0.4.4 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cvr/stacked",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/cevr/stacked"

package/src/commands/clean.ts

@@ -4,7 +4,7 @@ import { GitService } from "../services/Git.js";
 import { GitHubService } from "../services/GitHub.js";
 import { StackService } from "../services/Stack.js";
 import { ErrorCode, StackError } from "../errors/index.js";
-import { success, warn, dim, confirm } from "../ui.js";
+import { success, warn, dim, confirm, info } from "../ui.js";
 
 const dryRunFlag = Flag.boolean("dry-run").pipe(
   Flag.withDescription("Show what would be removed without making changes"),
@@ -73,7 +73,7 @@ export const clean = Command.make("clean", { dryRun: dryRunFlag, json: jsonFlag
           // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
           yield* Console.log(JSON.stringify({ removed: [], skipped: [] }, null, 2));
         } else {
-          yield* Console.error("Nothing to clean");
+          yield* info("Nothing to clean");
           if (skippedMerged.length > 0) {
             yield* warn(
               `${skippedMerged.length} merged branch${skippedMerged.length === 1 ? "" : "es"} skipped (non-merged branches below):`,
@@ -102,6 +102,7 @@ export const clean = Command.make("clean", { dryRun: dryRunFlag, json: jsonFlag
       }
 
       const removed: string[] = [];
+      const failed: string[] = [];
 
       for (const { stackName, branch } of toRemove) {
         if (dryRun) {
@@ -130,9 +131,10 @@ export const clean = Command.make("clean", { dryRun: dryRunFlag, json: jsonFlag
             );
           if (deleted) {
             yield* stacks.removeBranch(branch);
-            yield* stacks.markMergedBranches([branch]);
             removed.push(branch);
             yield* success(`Removed ${branch} from ${stackName}`);
+          } else {
+            failed.push(branch);
           }
         }
       }
@@ -140,7 +142,7 @@ export const clean = Command.make("clean", { dryRun: dryRunFlag, json: jsonFlag
       if (json) {
         const skipped = skippedMerged.map((x) => x.branch);
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
-        yield* Console.log(JSON.stringify({ removed, skipped }, null, 2));
+        yield* Console.log(JSON.stringify({ removed, failed, skipped }, null, 2));
       } else if (dryRun) {
         yield* Console.error(
           `\n${toRemove.length} branch${toRemove.length === 1 ? "" : "es"} would be removed`,

package/src/commands/delete.ts

@@ -50,6 +50,7 @@ export const deleteCmd = Command.make("delete", {
 
       if (idx < stack.branches.length - 1 && !force) {
         return yield* new StackError({
+          code: ErrorCode.HAS_CHILDREN,
           message: `Branch "${name}" has children. Use --force to delete anyway.`,
         });
       }

package/src/commands/detect.ts

@@ -37,7 +37,7 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
       const { untracked, skipped } = limitUntrackedBranches(untrackedAll, detectLimit);
 
       if (untracked.length === 0) {
-        yield* Console.error("No untracked branches found");
+        yield* info("No untracked branches found");
         return;
       }
 
@@ -50,8 +50,13 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
       const childOf = new Map<string, string>();
       const unclassified: string[] = [];
 
+      // Include both untracked and already-tracked branches in tip resolution
+      // so untracked branches can discover parents that are already in stacks
+      const trackedBranches = [...alreadyTracked];
+      const allCandidatesForTips = [...untracked, ...trackedBranches];
+
       const tipResults = yield* Effect.forEach(
-        untracked,
+        allCandidatesForTips,
         (branch) =>
           git.revParse(branch).pipe(
             Effect.map((oid) => [branch, oid] as const),
@@ -109,7 +114,7 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
       );
 
       // Build linear chains from trunk
-      // Find branches whose parent is trunk (chain roots)
+      // Find branches whose parent is trunk or a tracked branch (chain roots)
       const childrenByParent = new Map<string, string[]>();
       for (const branch of untracked) {
         const parent = childOf.get(branch);
@@ -119,17 +124,48 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
         childrenByParent.set(parent, children);
       }
 
+      // Branches whose parent is already tracked — extend existing stacks
+      const adoptions = new Map<string, string[]>(); // trackedParent → [children]
+      for (const branch of untracked) {
+        const parent = childOf.get(branch);
+        if (parent !== undefined && alreadyTracked.has(parent)) {
+          const siblings = childrenByParent.get(parent) ?? [];
+          if (siblings.length === 1) {
+            const existing = adoptions.get(parent) ?? [];
+            // Walk the chain from this branch
+            const chain = [branch];
+            let current = branch;
+            while (true) {
+              const children = childrenByParent.get(current) ?? [];
+              const child = children[0];
+              if (children.length === 1 && child !== undefined) {
+                chain.push(child);
+                current = child;
+              } else break;
+            }
+            adoptions.set(parent, [...existing, ...chain]);
+          }
+        }
+      }
+
       const chains: string[][] = [];
       const roots = childrenByParent.get(trunk) ?? [];
 
+      // Track branches consumed by adoptions so they're not double-counted
+      const adoptedBranches = new Set<string>();
+      for (const branches of adoptions.values()) {
+        for (const b of branches) adoptedBranches.add(b);
+      }
+
       for (const root of roots) {
+        if (adoptedBranches.has(root)) continue;
         const chain = [root];
         let current = root;
 
         while (true) {
           const children = childrenByParent.get(current) ?? [];
           const child = children[0];
-          if (children.length === 1 && child !== undefined) {
+          if (children.length === 1 && child !== undefined && !adoptedBranches.has(child)) {
             chain.push(child);
             current = child;
           } else {
@@ -150,16 +186,40 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
 
       if (json) {
         const stacksData = chains.map((chain) => ({ name: chain[0] ?? "", branches: chain }));
+        const adoptionData = [...adoptions.entries()].map(([parent, branches]) => ({
+          parent,
+          branches,
+        }));
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
-        yield* Console.log(JSON.stringify({ stacks: stacksData, forks }, null, 2));
+        yield* Console.log(
+          JSON.stringify({ stacks: stacksData, adoptions: adoptionData, forks }, null, 2),
+        );
         return;
       }
 
-      if (chains.length === 0) {
+      if (chains.length === 0 && adoptions.size === 0) {
         yield* info("No linear branch chains detected");
         return;
       }
 
+      // Adopt branches into existing stacks
+      for (const [parent, branches] of adoptions) {
+        const parentStack = yield* stacks.findBranchStack(parent);
+        if (parentStack === null) continue;
+        for (const branch of branches) {
+          if (dryRun) {
+            yield* Console.error(
+              `Would adopt "${branch}" into stack "${parentStack.name}" after "${parent}"`,
+            );
+          } else {
+            yield* stacks.addBranch(parentStack.name, branch, parent);
+            yield* success(
+              `Adopted "${branch}" into stack "${parentStack.name}" after "${parent}"`,
+            );
+          }
+        }
+      }
+
       for (const chain of chains) {
         const name = chain[0];
         if (name === undefined) continue;
@@ -177,9 +237,8 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
       }
 
       if (dryRun) {
-        yield* Console.error(
-          `\n${chains.length} stack${chains.length === 1 ? "" : "s"} would be created`,
-        );
+        const total = chains.length + adoptions.size;
+        yield* Console.error(`\n${total} action${total === 1 ? "" : "s"} would be performed`);
       }
 
       if (forks.length > 0) {

package/src/commands/doctor.ts

@@ -66,12 +66,14 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
       }
 
       // Check 2: all tracked branches exist in git
+      const allGitBranches = yield* git
+        .listBranches()
+        .pipe(Effect.catchTag("GitError", () => Effect.succeed([] as string[])));
+      const gitBranchSet = new Set(allGitBranches);
+
       for (const { name: stackName, stack } of stackEntries) {
         for (const branch of stack.branches) {
-          const exists = yield* git
-            .branchExists(branch)
-            .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
-          if (!exists) {
+          if (!gitBranchSet.has(branch)) {
             if (fix) {
               yield* stacks.removeBranch(branch);
               findings.push({

package/src/commands/helpers/pr-metadata.ts

@@ -99,17 +99,21 @@ export const refreshStackedPRBodies = ({
   getUserBody?: (branch: string, idx: number) => string | undefined;
 }) =>
   Effect.gen(function* () {
-    const prEntries = yield* Effect.all(
-      branches.map((branch) => {
+    const prEntries = yield* Effect.forEach(
+      branches,
+      (branch) => {
         const existing = initialPrMap?.get(branch);
         if (existing !== undefined) {
           return Effect.succeed([branch, existing] as const);
         }
         return gh.getPR(branch).pipe(Effect.map((pr) => [branch, pr] as const));
-      }),
+      },
+      { concurrency: 5 },
     );
     const prMap = new Map(prEntries);
 
+    // Collect all updates, then apply in parallel
+    const updates: Array<{ branch: string; body: string }> = [];
     for (let i = 0; i < branches.length; i++) {
       const branch = branches[i];
       if (branch === undefined) continue;
@@ -124,8 +128,12 @@ export const refreshStackedPRBodies = ({
         getUserBody?.(branch, i),
         metadata,
       );
-      yield* gh.updatePR({ branch, body });
+      updates.push({ branch, body });
     }
 
+    yield* Effect.forEach(updates, ({ branch, body }) => gh.updatePR({ branch, body }), {
+      concurrency: 5,
+    });
+
     return prMap;
   });

package/src/commands/index.ts

@@ -25,7 +25,7 @@ import { amend } from "./amend.js";
 
 const root = Command.make("stacked").pipe(
   Command.withDescription(
-    "Branch-based stacked PR manager\n\nGlobal flags:\n  --verbose       Show detailed output\n  --quiet, -q     Suppress non-essential output\n  --no-color      Disable color output\n  --yes, -y       Skip confirmation prompts",
+    "Branch-based stacked PR manager\n\nGlobal flags:\n  --verbose, -v   Show detailed output\n  --quiet, -q     Suppress non-essential output\n  --no-color      Disable color output\n  --yes, -y       Skip confirmation prompts",
   ),
   Command.withExamples([
     { command: "stacked create feat-auth", description: "Create a new branch in the stack" },

package/src/commands/init.ts

@@ -1,4 +1,4 @@
-import { Command } from "effect/unstable/cli";
+import { Command, Flag } from "effect/unstable/cli";
 import { Config, Console, Effect } from "effect";
 import { StackError } from "../errors/index.js";
 import { mkdirSync, writeFileSync } from "fs";
@@ -7,10 +7,12 @@ import { homedir } from "os";
 
 const skillContent = typeof __SKILL_CONTENT__ !== "undefined" ? __SKILL_CONTENT__ : null;
 
-export const init = Command.make("init").pipe(
+const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
+
+export const init = Command.make("init", { json: jsonFlag }).pipe(
   Command.withDescription("Install the stacked Claude skill to ~/.claude/skills"),
   Command.withExamples([{ command: "stacked init", description: "Install the Claude skill" }]),
-  Command.withHandler(() =>
+  Command.withHandler(({ json }) =>
     Effect.gen(function* () {
       if (skillContent === null) {
         return yield* new StackError({
@@ -24,7 +26,9 @@ export const init = Command.make("init").pipe(
       const targetDir = join(skillsDir, "stacked");
       const targetPath = join(targetDir, "SKILL.md");
 
-      yield* Console.error(`Writing skill to ${targetPath}...`);
+      if (!json) {
+        yield* Console.error(`Writing skill to ${targetPath}...`);
+      }
       yield* Effect.try({
         try: () => {
           mkdirSync(targetDir, { recursive: true });
@@ -33,12 +37,17 @@ export const init = Command.make("init").pipe(
         catch: (e) => new StackError({ message: `Failed to write skill: ${e}` }),
       });
 
-      yield* Console.error(`Installed stacked skill to ${targetPath}`);
-      yield* Console.error("\nNext steps:");
-      yield* Console.error("  stacked create <name>  # start your first stack");
-      yield* Console.error(
-        "  stacked trunk <name>   # only if auto-detection picks the wrong trunk",
-      );
+      if (json) {
+        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
+        yield* Console.log(JSON.stringify({ path: targetPath }, null, 2));
+      } else {
+        yield* Console.error(`Installed stacked skill to ${targetPath}`);
+        yield* Console.error("\nNext steps:");
+        yield* Console.error("  stacked create <name>  # start your first stack");
+        yield* Console.error(
+          "  stacked trunk <name>   # only if auto-detection picks the wrong trunk",
+        );
+      }
     }),
   ),
 );

package/src/commands/log.ts

@@ -28,13 +28,23 @@ export const log = Command.make("log", { json: jsonFlag }).pipe(
 
       const trunk = yield* stacks.getTrunk();
       const { branches } = result.stack;
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
+
+      const effectiveBase = (i: number): string => {
+        for (let j = i - 1; j >= 0; j--) {
+          const candidate = branches[j];
+          if (candidate !== undefined && !mergedSet.has(candidate)) return candidate;
+        }
+        return trunk;
+      };
 
       if (json) {
         const entries = [];
         for (let i = 0; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
-          const base = i === 0 ? trunk : (branches[i - 1] ?? trunk);
+          const base = effectiveBase(i);
           const commits = yield* git
             .log(`${base}..${branch}`, { oneline: true })
             .pipe(Effect.catchTag("GitError", () => Effect.succeed("")));
@@ -48,7 +58,7 @@ export const log = Command.make("log", { json: jsonFlag }).pipe(
       for (let i = 0; i < branches.length; i++) {
         const branch = branches[i];
         if (branch === undefined) continue;
-        const base = i === 0 ? trunk : (branches[i - 1] ?? trunk);
+        const base = effectiveBase(i);
         yield* Console.log(`\n── ${branch} ──`);
         const rangeLog = yield* git
           .log(`${base}..${branch}`, { oneline: true })

package/src/commands/reorder.ts

@@ -32,12 +32,14 @@ export const reorder = Command.make("reorder", {
 
       if (Option.isNone(before) && Option.isNone(after)) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: "Specify --before or --after to indicate target position",
         });
       }
 
       if (Option.isSome(before) && Option.isSome(after)) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: "Specify either --before or --after, not both",
         });
       }

package/src/commands/stacks.ts

@@ -2,7 +2,7 @@ import { Command, Flag } from "effect/unstable/cli";
 import { Console, Effect } from "effect";
 import { GitService } from "../services/Git.js";
 import { StackService } from "../services/Stack.js";
-import { stdout } from "../ui.js";
+import { stdout, info } from "../ui.js";
 
 const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
 
@@ -24,7 +24,7 @@ export const stacks = Command.make("stacks", { json: jsonFlag }).pipe(
           // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
           yield* Console.log(JSON.stringify({ stacks: [] }));
         } else {
-          yield* Console.error("No stacks");
+          yield* info("No stacks");
         }
         return;
       }

package/src/commands/submit.ts

@@ -90,6 +90,17 @@ export const submit = Command.make("submit", {
       const trunk = yield* stacks.getTrunk();
       const currentBranch = yield* git.currentBranch();
       const { branches } = result.stack;
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
+
+      // Compute the effective base for a branch at index i, skipping merged branches
+      const effectiveBase = (i: number): string => {
+        for (let j = i - 1; j >= 0; j--) {
+          const candidate = branches[j];
+          if (candidate !== undefined && !mergedSet.has(candidate)) return candidate;
+        }
+        return trunk;
+      };
 
       const rawTitle = Option.isSome(titleOpt) ? titleOpt.value : undefined;
       const rawBody = Option.isSome(bodyOpt) ? bodyOpt.value : undefined;
@@ -106,11 +117,13 @@ export const submit = Command.make("submit", {
 
       if (titles !== undefined && titles.length !== branches.length) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: `--title has ${titles.length} values but stack has ${branches.length} branches`,
         });
       }
       if (bodies !== undefined && bodies.length !== branches.length) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: `--body has ${bodies.length} values but stack has ${branches.length} branches`,
         });
       }
@@ -132,19 +145,34 @@ export const submit = Command.make("submit", {
       const results: SubmitResult[] = [];
       const prMap = new Map<
         string,
-        { number: number; url: string; state: string; body?: string | null } | null
+        { number: number; url: string; state: string; base: string; body?: string | null } | null
       >();
 
+      // Pre-fetch all PR statuses in parallel
+      const activeBranches = only ? branches.filter((b) => b === currentBranch) : [...branches];
+      const prResults = yield* Effect.forEach(
+        activeBranches,
+        (branch) =>
+          gh.getPR(branch).pipe(
+            Effect.map((pr) => [branch, pr] as const),
+            Effect.catchTag("GitHubError", () => Effect.succeed([branch, null] as const)),
+          ),
+        { concurrency: 5 },
+      );
+      for (const [branch, pr] of prResults) {
+        prMap.set(branch, pr);
+      }
+
       for (let i = 0; i < branches.length; i++) {
         const branch = branches[i];
         if (branch === undefined) continue;
-        const base = i === 0 ? trunk : (branches[i - 1] ?? trunk);
+        const base = effectiveBase(i);
 
         // --only: skip branches that aren't current
         if (only && branch !== currentBranch) continue;
 
         if (dryRun) {
-          const existingPR = yield* gh.getPR(branch);
+          const existingPR = prMap.get(branch) ?? null;
           const action =
             existingPR === null
               ? "would-create"
@@ -166,8 +194,7 @@ export const submit = Command.make("submit", {
 
         yield* withSpinner(`Pushing ${branch}`, git.push(branch, { force: !noForce }));
 
-        const existingPR = yield* gh.getPR(branch);
-        prMap.set(branch, existingPR);
+        const existingPR = prMap.get(branch) ?? null;
 
         if (existingPR !== null) {
           if (existingPR.base !== base) {
@@ -205,7 +232,7 @@ export const submit = Command.make("submit", {
             body,
             draft,
           });
-          prMap.set(branch, { number: pr.number, url: pr.url, state: "OPEN" });
+          prMap.set(branch, { number: pr.number, url: pr.url, state: "OPEN", base });
           yield* success(`Created PR #${pr.number}: ${pr.url}`);
           results.push({
             branch,

package/src/commands/sync.ts

@@ -72,6 +72,18 @@ export const sync = Command.make("sync", {
       }
 
       const { branches } = result.stack;
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
+
+      // Compute the effective base for a branch at index i, skipping merged branches
+      const effectiveBase = (i: number, fallback: string): string => {
+        for (let j = i - 1; j >= 0; j--) {
+          const candidate = branches[j];
+          if (candidate !== undefined && !mergedSet.has(candidate)) return candidate;
+        }
+        return fallback;
+      };
+
       const fromBranch = Option.isSome(fromOpt) ? fromOpt.value : undefined;
 
       let startIdx = 0;
@@ -101,7 +113,7 @@ export const sync = Command.make("sync", {
         for (let i = startIdx; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
-          const base = i === 0 ? originTrunk : (branches[i - 1] ?? originTrunk);
+          const base = effectiveBase(i, originTrunk);
           results.push({ name: branch, action: "skipped", base });
           if (!json) {
             yield* Console.error(`Would rebase and force-push ${branch} onto ${base}`);
@@ -137,7 +149,7 @@ export const sync = Command.make("sync", {
         for (let i = startIdx; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
-          const newBase = i === 0 ? originTrunk : (branches[i - 1] ?? originTrunk);
+          const newBase = effectiveBase(i, originTrunk);
 
           // Compute old base (merge-base of this branch and its parent) before rebasing
           const oldBase = yield* git

package/src/errors/index.ts

@@ -19,6 +19,8 @@ export const ErrorCode = {
   STACK_EMPTY: "STACK_EMPTY",
   TRUNK_ERROR: "TRUNK_ERROR",
   STACK_EXISTS: "STACK_EXISTS",
+  USAGE_ERROR: "USAGE_ERROR",
+  HAS_CHILDREN: "HAS_CHILDREN",
 } as const;
 
 export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];

package/src/main.ts

@@ -15,11 +15,11 @@ const version = typeof __VERSION__ !== "undefined" ? __VERSION__ : "dev";
 // Global Flags (parsed before CLI framework, stripped from argv)
 // ============================================================================
 
-const globalFlags = new Set(["--verbose", "--quiet", "-q", "--no-color", "--yes", "-y"]);
+const globalFlags = new Set(["--verbose", "-v", "--quiet", "-q", "--no-color", "--yes", "-y"]);
 const flagArgs = new Set(process.argv.filter((a) => globalFlags.has(a)));
 process.argv = process.argv.filter((a) => !globalFlags.has(a));
 
-const isVerbose = flagArgs.has("--verbose");
+const isVerbose = flagArgs.has("--verbose") || flagArgs.has("-v");
 const isQuiet = flagArgs.has("--quiet") || flagArgs.has("-q");
 const isNoColor = flagArgs.has("--no-color");
 const isYes = flagArgs.has("--yes") || flagArgs.has("-y");
@@ -53,16 +53,26 @@ const usageCodes = new Set([
   "ALREADY_AT_BOTTOM",
   "TRUNK_ERROR",
   "STACK_EXISTS",
+  "USAGE_ERROR",
+  "HAS_CHILDREN",
 ]);
 
-const handleKnownError = (e: { message: string; code?: string | undefined }) =>
-  Console.error(e.code !== undefined ? `Error [${e.code}]: ${e.message}` : e.message).pipe(
+const isJson = process.argv.includes("--json");
+
+const handleKnownError = (e: { message: string; code?: string | undefined }) => {
+  const exitCode = e.code !== undefined && usageCodes.has(e.code) ? 2 : 1;
+  const errorOutput = isJson
+    ? Console.log(JSON.stringify({ error: { code: e.code ?? null, message: e.message } }))
+    : Console.error(e.code !== undefined ? `Error [${e.code}]: ${e.message}` : e.message);
+
+  return errorOutput.pipe(
     Effect.andThen(
       Effect.sync(() => {
-        process.exitCode = e.code !== undefined && usageCodes.has(e.code) ? 2 : 1;
+        process.exitCode = exitCode;
       }),
     ),
   );
+};
 
 // @effect-diagnostics-next-line effect/strictEffectProvide:off
 BunRuntime.runMain(

package/src/services/Git.ts

@@ -121,7 +121,10 @@ export class GitService extends ServiceMap.Service<
 
       remoteDefaultBranch: (remote = "origin") =>
         run(["symbolic-ref", "--quiet", "--short", `refs/remotes/${remote}/HEAD`]).pipe(
-          Effect.map((ref) => Option.some(ref.replace(new RegExp(`^${remote}/`), ""))),
+          Effect.map((ref) => {
+            const prefix = `${remote}/`;
+            return Option.some(ref.startsWith(prefix) ? ref.slice(prefix.length) : ref);
+          }),
           Effect.catchTag("GitError", () => Effect.succeed(Option.none())),
         ),
 
@@ -192,9 +195,28 @@ export class GitService extends ServiceMap.Service<
         ),
 
       commitAmend: (options) => {
-        const args = ["commit", "--amend"];
-        if (options?.edit !== true) args.push("--no-edit");
-        return run(args).pipe(Effect.asVoid);
+        if (options?.edit === true) {
+          // Interactive editor needs inherited stdio, not piped
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(["git", "commit", "--amend"], {
+                stdin: "inherit",
+                stdout: "inherit",
+                stderr: "inherit",
+              });
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                throw new Error(`git commit --amend failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (e) =>
+              new GitError({
+                message: `Process failed: ${e}`,
+                command: "git commit --amend",
+              }),
+          }).pipe(Effect.asVoid);
+        }
+        return run(["commit", "--amend", "--no-edit"]).pipe(Effect.asVoid);
       },
 
       fetch: (remote) => run(["fetch", remote ?? "origin"]).pipe(Effect.asVoid),

package/src/services/GitEs.ts

@@ -111,7 +111,8 @@ export const GitEsLayer = Layer.effect(
             const ref = repo.findReference(`refs/remotes/${remote}/HEAD`);
             if (ref === null) return Option.none();
             const target = ref.resolve().shorthand();
-            return Option.some(target.replace(new RegExp(`^${remote}/`), ""));
+            const prefix = `${remote}/`;
+            return Option.some(target.startsWith(prefix) ? target.slice(prefix.length) : target);
           },
           catch: (error) => makeGitError(`es-git.remoteDefaultBranch ${remote}`, error),
         }).pipe(Effect.catchTag("GitError", () => Effect.succeed(Option.none()))),
@@ -127,13 +128,32 @@ export const GitEsLayer = Layer.effect(
           catch: (error) => makeGitError(`es-git.createBranch ${name}`, error),
         }).pipe(Effect.asVoid),
 
-      deleteBranch: (name) =>
-        Effect.try({
+      deleteBranch: (name, force) => {
+        // When force is false/undefined, shell out to `git branch -d` so git
+        // enforces "must be fully merged" check. es-git has no equivalent.
+        if (force !== true) {
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(["git", "branch", "-d", "--", name], {
+                stdout: "pipe",
+                stderr: "pipe",
+              });
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                const stderr = await new Response(proc.stderr).text();
+                throw new Error(stderr.trim() || `git branch -d failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (error) => makeGitError(`es-git.deleteBranch ${name}`, error),
+          }).pipe(Effect.asVoid);
+        }
+        return Effect.try({
           try: () => {
             repo.getBranch(name, "Local").delete();
           },
           catch: (error) => makeGitError(`es-git.deleteBranch ${name}`, error),
-        }).pipe(Effect.asVoid),
+        }).pipe(Effect.asVoid);
+      },
 
       checkout: (name) =>
         Effect.try({
@@ -177,17 +197,34 @@ export const GitEsLayer = Layer.effect(
           catch: (error) => makeGitError("es-git.rebaseAbort", error),
         }).pipe(Effect.asVoid),
 
-      push: (branch, options) =>
-        Effect.tryPromise({
+      push: (branch, options) => {
+        // es-git's protocol has no --force-with-lease equivalent; shell out to git CLI
+        if (options?.force === true) {
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(
+                ["git", "push", "--force-with-lease", "-u", "origin", branch],
+                { stdout: "pipe", stderr: "pipe" },
+              );
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                const stderr = await new Response(proc.stderr).text();
+                throw new Error(stderr.trim() || `git push failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (error) => makeGitError(`es-git.push ${branch}`, error),
+          }).pipe(Effect.asVoid);
+        }
+        return Effect.tryPromise({
           try: async () => {
             const remote = repo.getRemote("origin");
-            const forcePrefix = options?.force === true ? "+" : "";
-            await remote.push([`${forcePrefix}refs/heads/${branch}:refs/heads/${branch}`]);
+            await remote.push([`refs/heads/${branch}:refs/heads/${branch}`]);
             const localBranch = repo.findBranch(branch, "Local");
             localBranch?.setUpstream(`origin/${branch}`);
           },
           catch: (error) => makeGitError(`es-git.push ${branch}`, error),
-        }).pipe(Effect.asVoid),
+        }).pipe(Effect.asVoid);
+      },
 
       log: (branch, options) =>
         Effect.try({
@@ -274,8 +311,25 @@ export const GitEsLayer = Layer.effect(
           catch: (error) => makeGitError("es-git.isRebaseInProgress", error),
         }).pipe(Effect.catchTag("GitError", () => Effect.succeed(false))),
 
-      commitAmend: () =>
-        Effect.try({
+      commitAmend: (options) => {
+        // --edit requires an interactive editor; shell out to git CLI
+        if (options?.edit === true) {
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(["git", "commit", "--amend"], {
+                stdin: "inherit",
+                stdout: "inherit",
+                stderr: "inherit",
+              });
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                throw new Error(`git commit --amend failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (error) => makeGitError("es-git.commitAmend", error),
+          }).pipe(Effect.asVoid);
+        }
+        return Effect.try({
           try: () => {
             const headOid = repo.head().target();
             if (headOid === null) {
@@ -287,7 +341,8 @@ export const GitEsLayer = Layer.effect(
             });
           },
           catch: (error) => makeGitError("es-git.commitAmend", error),
-        }).pipe(Effect.asVoid),
+        }).pipe(Effect.asVoid);
+      },
 
       fetch: (remote = "origin") =>
         Effect.tryPromise({

package/src/services/Stack.ts

@@ -252,10 +252,8 @@ const rewriteStackBranches = (
     };
   }
 
-  const [root] = branches;
-  if (root === undefined) {
-    return data;
-  }
+  // branches.length > 0 guaranteed by the early return above
+  const root = branches[0] as string;
 
   return {
     ...data,
@@ -636,21 +634,19 @@ export class StackService extends ServiceMap.Service<
     readonly setTrunk: (name: string) => Effect.Effect<void, StackError>;
   }
 >()("@cvr/stacked/services/Stack/StackService") {
-  static layer: Layer.Layer<StackService, never, GitService> = Layer.effect(
+  static layer: Layer.Layer<StackService, StackError, GitService> = Layer.effect(
     StackService,
     Effect.gen(function* () {
       const git = yield* GitService;
 
-      const stackFilePath = Effect.fn("StackService.stackFilePath")(function* () {
-        const gitDir = yield* git
-          .revParse("--absolute-git-dir")
-          .pipe(
-            Effect.mapError(
-              (e) => new StackError({ message: `Not a git repository: ${e.message}` }),
-            ),
-          );
-        return `${gitDir}/stacked.json`;
-      });
+      // Resolve git dir once at construction time, then capture in closure
+      const gitDir = yield* git
+        .revParse("--absolute-git-dir")
+        .pipe(
+          Effect.mapError((e) => new StackError({ message: `Not a git repository: ${e.message}` })),
+        );
+      const resolvedStackFilePath = `${gitDir}/stacked.json`;
+      const stackFilePath = () => Effect.succeed(resolvedStackFilePath);
 
       const StackFileJson = Schema.fromJsonString(
         Schema.Union([StackFileV1Schema, StackFileV2Schema]),