@cvr/stacked 0.4.4 → 0.6.0

package/package.json

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

package/skills/stacked/SKILL.md

@@ -45,7 +45,7 @@ What do you need?
 | `stacked down`               | Move down one branch in the stack                                                           |
 | `stacked top`                | Jump to top of stack                                                                        |
 | `stacked bottom`             | Jump to bottom of stack                                                                     |
-| `stacked sync`               | Fetch + rebase + force-push stack on trunk (`--from`, `--dry-run`, `--json`)                |
+| `stacked sync`               | Fetch + sync stack on trunk (`--from`, `--dry-run`, `--rebase-only`, `--json`)              |
 | `stacked detect`             | Detect branch chains and register as stacks (`--dry-run`, `--json`)                         |
 | `stacked clean`              | Remove merged branches + remote branches (`--dry-run`, `--json`)                            |
 | `stacked delete <name>`      | Remove branch from stack + git + remote (`--keep-remote`, `--force`, `--dry-run`, `--json`) |
@@ -143,23 +143,33 @@ All navigation commands support `--json` for structured output. `checkout` falls
 
 ## Syncing / Rebasing / Pushing
 
-Fetch latest trunk, rebase the entire stack bottom-to-top, then force-push each rebased branch (`--force-with-lease`):
+Fetch latest trunk, then incrementally sync the stack bottom-to-top using fork-point tracking:
 
 ```sh
 stacked sync
-stacked sync --dry-run    # preview rebase/push plan without executing
-stacked sync --json       # structured output: { branches: [{ name, action, base }] }
+stacked sync --dry-run       # preview sync plan with predicted actions per branch
+stacked sync --rebase-only   # force rebase path (skip tree-merge)
+stacked sync --json          # structured output: { branches: [{ name, action, base }] }
 ```
 
-After mid-stack changes, rebase only the branches above a specific point:
+**How sync works:**
+
+1. Fetch and rebase trunk onto `origin/trunk`
+2. For each branch, check if parent moved since last sync (`syncedOnto` metadata)
+3. If parent unchanged → skip (no push needed)
+4. If parent changed → try tree-merge fast path (es-git: `mergeTrees`, creates merge commit, no replay)
+5. If tree-merge conflicts → fall back to rebase with corrected fork-point as `oldBase`
+6. Force-push changed branches, update `syncedOnto` metadata
+
+After mid-stack changes, sync only the branches above a specific point:
 
 ```sh
 stacked checkout feat-auth
 # ... make changes, commit ...
-stacked sync --from feat-auth    # rebases only children of feat-auth
+stacked sync --from feat-auth    # syncs only children of feat-auth
 ```
 
-**Note:** `sync` requires a clean working tree — commit or stash before running (except with `--dry-run`). On rebase conflict, the rebase is left in progress so you can resolve it:
+**Note:** `sync` requires a clean working tree — commit or stash before running (except with `--dry-run`). On rebase conflict (fallback path), the rebase is left in progress so you can resolve it:
 
 ```sh
 # On conflict:
@@ -311,10 +321,11 @@ Usage errors (invalid args, bad state) exit code 2. Operational errors (git/gh f
 
 ## Data Model
 
-Stack metadata lives in `.git/stacked.json`. Each branch's parent is implied by array position:
+Stack metadata lives in `.git/stacked.json`. Each branch record stores:
 
-- `branches[0]` → parent is trunk
-- `branches[n]` → parent is `branches[n-1]`
+- `stack` — which stack it belongs to
+- `parent` — parent branch name (null for root)
+- `syncedOnto` — (optional) the parent branch tip SHA at last sync, used for incremental sync
 
 Trunk is auto-detected on first use from `origin/HEAD` when available, then falls back to local `main`, `master`, or `develop`. Override with `stacked trunk <name>`.
 
@@ -356,8 +367,10 @@ stacked down  # go to previous branch
 ## Gotchas
 
 - `stacked sync` requires a clean working tree — commit or stash first (except `--dry-run`)
-- `stacked sync` rebases bottom-to-top and force-pushes each rebased branch with lease
-- `stacked sync` leaves rebase in progress on conflict — resolve with `git rebase --continue`, then resume with `stacked sync --from <parent>`
+- `stacked sync` uses tree-merge by default (es-git); falls back to rebase on conflict or CLI backend
+- `stacked sync` skips branches whose parent hasn't moved since last sync
+- `stacked sync` leaves rebase in progress on conflict (fallback path) — resolve with `git rebase --continue`, then resume with `stacked sync --from <parent>`
+- `syncedOnto` metadata may become stale if branches are rebased outside `stacked` — first sync after that falls back to `merge-base`
 - `stacked submit` force-pushes by default (use `--no-force` to disable)
 - `stacked submit` and `stacked clean` require `gh` CLI authenticated (`gh auth login`)
 - PRs target parent branches, not trunk — this is intentional for stacked review
@@ -369,4 +382,5 @@ stacked down  # go to previous branch
 - Detached HEAD is detected and produces a clear error — checkout a branch first
 - Stack file writes are atomic (write to tmp, then rename) to prevent corruption
 - `create` and `adopt` are idempotent — safe to re-run after transient failures
-- Use `stacked doctor` to detect and fix metadata drift (stale branches, missing trunk)
+- Use `stacked doctor` to detect and fix metadata drift (stale branches, missing trunk, stale syncedOnto)
+- `stacked doctor --fix` clears stale `syncedOnto` entries pointing at non-existent commits

package/src/commands/adopt.ts

@@ -87,6 +87,15 @@ export const adopt = Command.make("adopt", {
         yield* stacks.addBranch(result.name, branch, afterBranch);
       }
 
+      // Record fork-point for incremental sync based on the branch's merge-base with its parent
+      const parentRef = Option.isSome(after) ? after.value : yield* git.currentBranch();
+      const parentTip = yield* git
+        .mergeBase(branch, parentRef)
+        .pipe(Effect.catchTag("GitError", () => git.revParse(parentRef)));
+      yield* stacks
+        .updateSyncedOnto(branch, parentTip)
+        .pipe(Effect.catchTag("StackError", () => Effect.void));
+
       if (json) {
         const stackResult = yield* stacks.currentStack();
         const stackName = stackResult?.name ?? branch;

package/src/commands/amend.ts

@@ -61,34 +61,70 @@ export const amend = Command.make("amend", {
         return;
       }
 
-      // Rebase children
+      // Sync children using fork-point-aware algorithm
       const children = branches.slice(idx + 1);
       const synced: string[] = [];
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
 
       yield* Effect.gen(function* () {
         for (let i = 0; i < children.length; i++) {
           const branch = children[i];
           if (branch === undefined) continue;
-          const newBase = i === 0 ? fromBranch : (children[i - 1] ?? fromBranch);
+          // Compute effective base, skipping merged branches (same as sync)
+          let newBase = fromBranch;
+          for (let j = i - 1; j >= 0; j--) {
+            const candidate = children[j];
+            if (candidate !== undefined && !mergedSet.has(candidate)) {
+              newBase = candidate;
+              break;
+            }
+          }
 
-          const oldBase = yield* git
-            .mergeBase(branch, newBase)
-            .pipe(Effect.catchTag("GitError", () => Effect.succeed(newBase)));
+          const newBaseTip = yield* git.revParse(newBase);
+          const branchHead = yield* git.revParse(branch);
+          const syncedOnto = yield* stacks.getSyncedOnto(branch);
 
-          yield* git.checkout(branch);
-          yield* withSpinner(
-            `Rebasing ${branch} onto ${newBase}`,
-            git.rebaseOnto(branch, newBase, oldBase),
-          ).pipe(
-            Effect.catchTag("GitError", (e) =>
-              Effect.fail(
-                new StackError({
-                  code: ErrorCode.REBASE_CONFLICT,
-                  message: `Rebase conflict on ${branch}: ${e.message}\n\nResolve conflicts, then run:\n  git rebase --continue`,
-                }),
+          // Resolve old base: prefer recorded fork-point, fall back to merge-base
+          const oldBase =
+            syncedOnto ??
+            (yield* git
+              .mergeBase(branch, newBase)
+              .pipe(Effect.catchTag("GitError", () => Effect.succeed(newBase))));
+
+          // Try tree-merge fast path
+          const mergeResult = yield* git
+            .treeMergeSync({
+              branch,
+              branchHead,
+              oldBase,
+              newBase: newBaseTip,
+              message: `sync: incorporate changes from ${newBase}`,
+            })
+            .pipe(
+              Effect.catchTag("GitError", () => Effect.succeed({ action: "conflict" as const })),
+            );
+
+          if (mergeResult.action === "merged" || mergeResult.action === "up-to-date") {
+            yield* stacks.updateSyncedOnto(branch, newBaseTip);
+          } else {
+            // Conflict — fall back to rebase with corrected oldBase
+            yield* git.checkout(branch);
+            yield* withSpinner(
+              `Rebasing ${branch} onto ${newBase}`,
+              git.rebaseOnto(branch, newBase, oldBase),
+            ).pipe(
+              Effect.catchTag("GitError", (e) =>
+                Effect.fail(
+                  new StackError({
+                    code: ErrorCode.REBASE_CONFLICT,
+                    message: `Rebase conflict on ${branch}: ${e.message}\n\nResolve conflicts, then run:\n  git rebase --continue`,
+                  }),
+                ),
               ),
-            ),
-          );
+            );
+            yield* stacks.updateSyncedOnto(branch, newBaseTip);
+          }
           synced.push(branch);
         }
       }).pipe(

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

@@ -99,6 +99,10 @@ export const create = Command.make("create", {
         yield* stacks.addBranch(stackName, name, baseBranch === trunk ? undefined : baseBranch);
       }
 
+      // Record the fork-point for incremental sync
+      const baseTip = yield* git.revParse(baseBranch);
+      yield* stacks.updateSyncedOnto(name, baseTip);
+
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
         yield* Console.log(

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

@@ -8,7 +8,7 @@ const fixFlag = Flag.boolean("fix").pipe(Flag.withDescription("Auto-fix issues w
 const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"));
 
 interface Finding {
-  type: "stale_branch" | "missing_trunk" | "duplicate_branch" | "parse_error";
+  type: "stale_branch" | "missing_trunk" | "duplicate_branch" | "stale_fork_point" | "parse_error";
   message: string;
   fixed: boolean;
 }
@@ -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({
@@ -107,6 +109,33 @@ export const doctor = Command.make("doctor", { fix: fixFlag, json: jsonFlag }).p
         }
       }
 
+      // Check 4: syncedOnto entries point at valid commits
+      for (const [branch, record] of Object.entries(data.branches)) {
+        if (record.syncedOnto == null) continue;
+        const valid = yield* git.revParse(record.syncedOnto).pipe(
+          Effect.as(true),
+          Effect.catchTag("GitError", () => Effect.succeed(false)),
+        );
+        if (!valid) {
+          if (fix) {
+            yield* stacks
+              .updateSyncedOnto(branch, null)
+              .pipe(Effect.catchTag("StackError", () => Effect.void));
+            findings.push({
+              type: "stale_fork_point",
+              message: `Cleared stale syncedOnto for "${branch}" (commit ${record.syncedOnto.slice(0, 7)} no longer exists)`,
+              fixed: true,
+            });
+          } else {
+            findings.push({
+              type: "stale_fork_point",
+              message: `Branch "${branch}" has stale syncedOnto (commit ${record.syncedOnto.slice(0, 7)} no longer exists)`,
+              fixed: false,
+            });
+          }
+        }
+      }
+
       if (json) {
         // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
         yield* Console.log(JSON.stringify({ findings }, null, 2));

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;
       }