@cvr/stacked 0.4.3 → 0.5.0

package/src/commands/create.ts

@@ -80,20 +80,24 @@ export const create = Command.make("create", {
 
       const existing = yield* stacks.findBranchStack(baseBranch);
       let stackName = existing?.name ?? null;
+      let shouldAddBranch = true;
 
       yield* git.createBranch(name, baseBranch);
 
       if (stackName === null) {
         if (baseBranch === trunk) {
           stackName = name;
-          yield* stacks.createStack(name, []);
+          shouldAddBranch = false;
+          yield* stacks.createStack(name, [name]);
         } else {
           stackName = baseBranch;
           yield* stacks.createStack(baseBranch, [baseBranch]);
         }
       }
 
-      yield* stacks.addBranch(stackName, name, baseBranch === trunk ? undefined : baseBranch);
+      if (shouldAddBranch) {
+        yield* stacks.addBranch(stackName, name, baseBranch === trunk ? undefined : baseBranch);
+      }
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off

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.`,
         });
       }
@@ -101,7 +102,7 @@ export const deleteCmd = Command.make("delete", {
       }
 
       yield* git.deleteBranch(name, force);
-      yield* stacks.removeBranch(stackName, name);
+      yield* stacks.removeBranch(name);
 
       if (willDeleteRemote) {
         yield* git.deleteRemoteBranch(name).pipe(Effect.catchTag("GitError", () => Effect.void));

package/src/commands/detect.ts

@@ -5,6 +5,8 @@ import { StackService } from "../services/Stack.js";
 import { success, warn, info } from "../ui.js";
 import { detectLimitConfig, limitUntrackedBranches } from "./helpers/detect.js";
 
+const DETECT_COMMIT_LIMIT = 2048;
+
 const dryRunFlag = Flag.boolean("dry-run").pipe(
   Flag.withDescription("Show what would be detected without making changes"),
 );
@@ -26,13 +28,16 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
       const candidates = allBranches.filter((b) => b !== trunk);
 
       const data = yield* stacks.load();
-      const alreadyTracked = new Set(Object.values(data.stacks).flatMap((s) => [...s.branches]));
-      const untrackedAll = candidates.filter((b) => !alreadyTracked.has(b));
+      const alreadyTracked = new Set(Object.keys(data.branches));
+      const mergedBranches = new Set(data.mergedBranches);
+      const untrackedAll = candidates.filter(
+        (b) => !alreadyTracked.has(b) && !mergedBranches.has(b),
+      );
       const detectLimit = yield* detectLimitConfig;
       const { untracked, skipped } = limitUntrackedBranches(untrackedAll, detectLimit);
 
       if (untracked.length === 0) {
-        yield* Console.error("No untracked branches found");
+        yield* info("No untracked branches found");
         return;
       }
 
@@ -42,48 +47,74 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
         );
       }
 
-      // Build parent map: for each branch, find its direct parent among other branches
-      // A parent is the closest ancestor — i.e., an ancestor that is not an ancestor of another ancestor
       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(
+        allCandidatesForTips,
+        (branch) =>
+          git.revParse(branch).pipe(
+            Effect.map((oid) => [branch, oid] as const),
+            Effect.catchTag("GitError", () => Effect.succeed(null)),
+          ),
+        { concurrency: 5 },
+      );
+
+      const tipOwners = new Map<string, string[]>();
+      for (const result of tipResults) {
+        if (result === null) continue;
+        const [branch, oid] = result;
+        const owners = tipOwners.get(oid) ?? [];
+        owners.push(branch);
+        tipOwners.set(oid, owners);
+      }
 
       yield* Effect.forEach(
         untracked,
         (branch) =>
           Effect.gen(function* () {
-            // Check all potential ancestors (trunk + other untracked) in parallel
-            const potentialAncestors = [trunk, ...untracked.filter((b) => b !== branch)];
-            const ancestryResults = yield* Effect.forEach(
-              potentialAncestors,
-              (other) =>
-                git.isAncestor(other, branch).pipe(
-                  Effect.catchTag("GitError", () => Effect.succeed(false)),
-                  Effect.map((is) => [other, is] as const),
-                ),
-              { concurrency: 5 },
-            );
+            const commits = yield* git
+              .firstParentUniqueCommits(branch, trunk, { limit: DETECT_COMMIT_LIMIT })
+              .pipe(Effect.catchTag("GitError", () => Effect.succeed([])));
 
-            const ancestors = ancestryResults.filter(([_, is]) => is).map(([name]) => name);
+            if (commits.length === 0) {
+              unclassified.push(branch);
+              return;
+            }
 
-            if (ancestors.length === 0) return;
+            let parent: string | null = null;
+            let ambiguous = false;
 
-            // Find the closest ancestor — the one that is a descendant of all others
-            let closest = ancestors[0] ?? trunk;
-            for (let i = 1; i < ancestors.length; i++) {
-              const candidate = ancestors[i];
-              if (candidate === undefined) continue;
-              const candidateIsCloser = yield* git
-                .isAncestor(closest, candidate)
-                .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
-              if (candidateIsCloser) closest = candidate;
+            for (const oid of commits) {
+              const owners = (tipOwners.get(oid) ?? []).filter((owner) => owner !== branch);
+              if (owners.length > 1) {
+                ambiguous = true;
+                break;
+              }
+              const [owner] = owners;
+              if (owner !== undefined) {
+                parent = owner;
+                break;
+              }
             }
 
-            childOf.set(branch, closest);
+            if (ambiguous || (commits.length >= DETECT_COMMIT_LIMIT && parent === null)) {
+              unclassified.push(branch);
+              return;
+            }
+
+            childOf.set(branch, parent ?? trunk);
           }),
         { concurrency: 5 },
       );
 
       // 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);
@@ -93,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 {
@@ -124,21 +186,45 @@ 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;
-        const currentData = yield* stacks.load();
-        if (currentData.stacks[name] !== undefined) {
+        const existing = yield* stacks.getStack(name);
+        if (existing !== null) {
           yield* warn(`Stack "${name}" already exists, skipping: ${chain.join(" → ")}`);
           continue;
         }
@@ -151,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) {
@@ -162,6 +247,12 @@ export const detect = Command.make("detect", { dryRun: dryRunFlag, json: jsonFla
           yield* Console.error(`  ${fork.branch} → ${fork.children.join(", ")}`);
         }
       }
+
+      if (unclassified.length > 0 && !json) {
+        yield* warn(
+          `Skipped ${unclassified.length} unclassified branch${unclassified.length === 1 ? "" : "es"}: ${unclassified.join(", ")}`,
+        );
+      }
     }),
   ),
 );

package/src/commands/doctor.ts

@@ -26,6 +26,14 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
 
       const data = yield* stacks.load();
       const findings: Finding[] = [];
+      const stackEntries = yield* stacks.listStacks().pipe(
+        Effect.catchTag("StackError", (error) =>
+          Effect.sync(() => {
+            findings.push({ type: "parse_error", message: error.message, fixed: false });
+            return [] as const;
+          }),
+        ),
+      );
 
       // Check 1: trunk branch exists
       const trunkExists = yield* git
@@ -58,14 +66,16 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
       }
 
       // Check 2: all tracked branches exist in git
-      for (const [stackName, stack] of Object.entries(data.stacks)) {
+      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(stackName, branch);
+              yield* stacks.removeBranch(branch);
               findings.push({
                 type: "stale_branch",
                 message: `Removed stale branch "${branch}" from stack "${stackName}"`,
@@ -84,12 +94,10 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
 
       // Check 3: no branches in multiple stacks
       const branchToStacks = new Map<string, string[]>();
-      for (const [stackName, stack] of Object.entries(data.stacks)) {
-        for (const branch of stack.branches) {
-          const existing = branchToStacks.get(branch) ?? [];
-          existing.push(stackName);
-          branchToStacks.set(branch, existing);
-        }
+      for (const [branch, record] of Object.entries(data.branches)) {
+        const existing = branchToStacks.get(branch) ?? [];
+        existing.push(record.stack);
+        branchToStacks.set(branch, existing);
       }
       for (const [branch, stackNames] of branchToStacks) {
         if (stackNames.length > 1) {

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

@@ -0,0 +1,139 @@
+import type { ServiceMap } from "effect";
+import { Effect } from "effect";
+import type { GitHubService } from "../../services/GitHub.js";
+
+const STACKED_MARKER_START = "<!-- stacked -->";
+const STACKED_MARKER_END = "<!-- /stacked -->";
+
+type PullRequest = {
+  number: number;
+  url: string;
+  state: string;
+  body?: string | null;
+} | null;
+
+type GitHubApi = ServiceMap.Service.Shape<typeof GitHubService>;
+
+export const generateStackMetadata = (
+  branches: readonly string[],
+  prMap: Map<string, PullRequest>,
+  currentIdx: number,
+  stackName: string,
+): string => {
+  const rows = branches.map((branch, i) => {
+    const pr = prMap.get(branch) ?? null;
+    const isCurrent = i === currentIdx;
+    const branchCol = isCurrent ? `**\`${branch}\`**` : `\`${branch}\``;
+    const numCol = i + 1;
+    const numStr = isCurrent ? `**${numCol}**` : `${numCol}`;
+
+    let prCol: string;
+    if (pr === null) {
+      prCol = "—";
+    } else if (pr.state === "MERGED") {
+      prCol = `[#${pr.number}](${pr.url}) ✅`;
+    } else if (isCurrent) {
+      prCol = `**#${pr.number} ← you are here**`;
+    } else {
+      prCol = `[#${pr.number}](${pr.url})`;
+    }
+
+    return `| ${numStr} | ${branchCol} | ${prCol} |`;
+  });
+
+  return [
+    STACKED_MARKER_START,
+    `**Stack: \`${stackName}\`** (${currentIdx + 1} of ${branches.length})`,
+    "",
+    "| # | Branch | PR |",
+    "|---|--------|----|",
+    ...rows,
+    STACKED_MARKER_END,
+  ].join("\n");
+};
+
+export const composePRBody = (userBody: string | undefined, metadata: string): string => {
+  if (userBody !== undefined) {
+    return `${userBody}\n\n---\n\n${metadata}`;
+  }
+  return metadata;
+};
+
+export const updatePRBody = (
+  existingBody: string | undefined,
+  userBody: string | undefined,
+  metadata: string,
+): string => {
+  if (userBody !== undefined) {
+    return composePRBody(userBody, metadata);
+  }
+
+  if (existingBody !== undefined) {
+    const startIdx = existingBody.indexOf(STACKED_MARKER_START);
+    if (startIdx !== -1) {
+      const prefix = existingBody.substring(0, startIdx).replace(/\n*---\n*$/, "");
+      if (prefix.trim().length > 0) {
+        return `${prefix.trim()}\n\n---\n\n${metadata}`;
+      }
+      return metadata;
+    }
+    return `${existingBody.trim()}\n\n---\n\n${metadata}`;
+  }
+
+  return metadata;
+};
+
+export const refreshStackedPRBodies = ({
+  branches,
+  stackName,
+  gh,
+  initialPrMap,
+  shouldUpdateBranch,
+  getUserBody,
+}: {
+  branches: readonly string[];
+  stackName: string;
+  gh: GitHubApi;
+  initialPrMap?: Map<string, PullRequest>;
+  shouldUpdateBranch?: (branch: string) => boolean;
+  getUserBody?: (branch: string, idx: number) => string | undefined;
+}) =>
+  Effect.gen(function* () {
+    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;
+      if (shouldUpdateBranch !== undefined && !shouldUpdateBranch(branch)) continue;
+
+      const existingPrData = prMap.get(branch) ?? null;
+      if (existingPrData === null || existingPrData.state !== "OPEN") continue;
+
+      const metadata = generateStackMetadata(branches, prMap, i, stackName);
+      const body = updatePRBody(
+        existingPrData.body ?? undefined,
+        getUserBody?.(branch, i),
+        metadata,
+      );
+      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/list.ts

@@ -25,15 +25,14 @@ export const list = Command.make("list", { stackName: stackNameArg, json: jsonFl
       const stacks = yield* StackService;
 
       const currentBranch = yield* git.currentBranch();
-      const data = yield* stacks.load();
-      const trunk = data.trunk;
+      const trunk = yield* stacks.getTrunk();
 
       let targetStackName: string | null = null;
       let targetStack: { readonly branches: readonly string[] } | null = null;
 
       if (Option.isSome(stackName)) {
-        const s = data.stacks[stackName.value];
-        if (s === undefined) {
+        const s = yield* stacks.getStack(stackName.value);
+        if (s === null) {
           return yield* new StackError({
             code: ErrorCode.STACK_NOT_FOUND,
             message: `Stack "${stackName.value}" not found`,

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/rename.ts

@@ -16,27 +16,23 @@ export const rename = Command.make("rename", { old: oldArg, new: newArg, json: j
   Command.withHandler(({ old: oldName, new: newName, json }) =>
     Effect.gen(function* () {
       const stacks = yield* StackService;
-
-      const data = yield* stacks.load();
-
-      if (data.stacks[oldName] === undefined) {
+      const existing = yield* stacks.getStack(oldName);
+      if (existing === null) {
         return yield* new StackError({
           code: ErrorCode.STACK_NOT_FOUND,
           message: `Stack "${oldName}" not found`,
         });
       }
 
-      if (data.stacks[newName] !== undefined) {
+      const collision = yield* stacks.getStack(newName);
+      if (collision !== null) {
         return yield* new StackError({
           code: ErrorCode.STACK_EXISTS,
           message: `Stack "${newName}" already exists`,
         });
       }
 
-      const stack = data.stacks[oldName];
-      if (stack === undefined) return;
-      const { [oldName]: _, ...rest } = data.stacks;
-      yield* stacks.save({ ...data, stacks: { ...rest, [newName]: stack } });
+      yield* stacks.renameStack(oldName, newName);
 
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off