ctree 0.5.3

data/lib/ctree/list.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ctree
+  module List
+    module_function
+
+    def run(filter: nil, show_current: true)
+      source_root = Pathname.pwd
+      toplevel_out, _, status = Sh.capture3("git", "-C", source_root.to_s, "rev-parse", "--show-toplevel")
+      Log.die "not inside a git repository" unless status.success?
+      git_top = Pathname.new(toplevel_out.strip)
+      unless source_root.realpath == git_top.realpath
+        Log.die "must be invoked from project top-level (cwd=#{source_root}, top=#{git_top})"
+      end
+
+      cfg = Config.load(source_root)
+      Log.log_prefix = cfg[:log_prefix]
+      empty_prefix = cfg[:free_branch_prefix]
+
+      raw, _, st = Sh.capture3("git", "-C", source_root.to_s, "worktree", "list", "--porcelain")
+      Log.die "git worktree list failed" unless st.success?
+
+      entries = parse_worktree_porcelain(raw)
+
+      current_top = git_top.realpath.to_s
+      entries.each do |entry|
+        entry[:current] = (Pathname.new(entry[:path]).realpath.to_s == current_top)
+      rescue SystemCallError
+        entry[:current] = false
+      end
+
+      if !empty_prefix.nil? && !empty_prefix.empty?
+        entries.each do |entry|
+          branch = entry[:branch] || ""
+          entry[:free] = branch.start_with?(empty_prefix)
+        end
+      end
+
+      visible = case filter
+                when :free then entries.select { |e| e[:free] }
+                when :used then entries.reject { |e| e[:free] }
+                else entries
+                end
+
+      puts
+      puts "=== worktrees ==="
+      puts
+
+      if (filter == :free || filter == :used) && visible.empty?
+        if empty_prefix.nil? || empty_prefix.empty?
+          puts "  (free_branch_prefix not set in .ctree/config.yml)"
+        elsif filter == :free
+          puts "  no free worktrees matching \"#{empty_prefix}\""
+        else
+          puts "  no used worktrees"
+        end
+        puts
+        return
+      end
+
+      name_width = visible.map { |e| File.basename(e[:path]).length }.max.to_i
+
+      visible.each do |entry|
+        name   = File.basename(entry[:path]).ljust(name_width)
+        branch = entry[:branch] || "detached"
+        branch_label = (entry[:free] ? "#{branch} (free)" : branch)
+        tags = []
+        tags << "source" if entry[:source]
+        tags << "current" if entry[:current] && show_current
+        marker = tags.empty? ? "" : " ← #{tags.join(", ")}"
+        puts "  #{name}  #{entry[:path]}  [#{branch_label}]#{marker}"
+      end
+
+      puts
+    end
+
+    def parse_worktree_porcelain(raw)
+      entries = []
+      current = {}
+
+      raw.each_line do |line|
+        line = line.chomp
+        if line.empty?
+          entries << current unless current.empty?
+          current = {}
+        elsif line.start_with?("worktree ")
+          current[:path] = line.sub("worktree ", "")
+        elsif line.start_with?("branch ")
+          current[:branch] = line.sub("branch refs/heads/", "").sub("branch ", "")
+        elsif line == "detached"
+          current[:branch] = nil
+        end
+      end
+      entries << current unless current.empty?
+
+      # Mark the first entry (main worktree) as source.
+      entries.first[:source] = true if entries.any?
+      entries
+    end
+  end
+end

data/lib/ctree/rebase.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Ctree
+  module Rebase
+    module_function
+
+    # Runs from INSIDE a worktree. Rebases the worktree's feature branch onto
+    # the source's local master, then rebases each embedded repo (discovered
+    # via rebase config) from its source counterpart.
+    #
+    # All operations are local — no network calls. The source is the authority:
+    # rebase the source repo first, then run `ctree rebase` from the worktree
+    # to catch it up.
+    def run(force: false)
+      target_path = Pathname.pwd
+      toplevel_out, _, status = Sh.capture3("git", "-C", target_path.to_s, "rev-parse", "--show-toplevel")
+      Log.die "not inside a git repository" unless status.success?
+      git_top = Pathname.new(toplevel_out.strip)
+      unless target_path.realpath == git_top.realpath
+        Log.die "must be invoked from the worktree top-level (cwd=#{target_path}, top=#{git_top})"
+      end
+
+      common_out, _, c_st = Sh.capture3("git", "-C", target_path.to_s, "rev-parse", "--git-common-dir")
+      Log.die "could not resolve git common dir" unless c_st.success?
+      common = Pathname.new(common_out.strip)
+      common = (target_path / common) unless common.absolute?
+      source_root = common.parent.realpath
+
+      if source_root == target_path.realpath
+        Log.die "already in the source project; run ctree rebase from inside a worktree"
+      end
+
+      branch_out, _, _ = Sh.capture3("git", "-C", target_path.to_s, "rev-parse", "--abbrev-ref", "HEAD")
+      current_branch = branch_out.strip
+      if current_branch == "master" || current_branch == "main"
+        Log.die "worktree is on '#{current_branch}' — ctree rebase is for feature branches only; " \
+                "run `git pull --rebase origin #{current_branch}` directly"
+      end
+
+      config = Config.load(target_path)
+      Log.debug_mode = config[:log_level] == "debug"
+      Log.log_prefix = config[:log_prefix]
+      rebase_repo_paths = config[:rebase]
+
+      Log.info "rebasing worktree #{target_path.basename} from #{source_root.basename}"
+      Log.info "worktree:  #{target_path}  [#{current_branch}]"
+      Log.info "source:    #{source_root}"
+
+      # === uncommitted-changes check ===
+
+      dirty = []
+      dirty << target_path.to_s unless working_tree_clean?(target_path)
+      embedded_repos(target_path, rebase_repo_paths).each do |wt_repo|
+        dirty << wt_repo.to_s unless working_tree_clean?(wt_repo)
+      end
+
+      unless dirty.empty?
+        Log.warn_ "uncommitted changes in:"
+        dirty.each { |d| Log.warn_ "  #{d}" }
+        unless Prompt.confirm("proceed anyway? [y/N]:", default: :no, force: force)
+          Log.info "rebase aborted"
+          exit 1
+        end
+      end
+
+      results = []
+
+      default_branch = Git.detect_default_branch(source_root)
+
+      # === rebase worktree feature branch onto source's default branch ===
+
+      status = rebase_branch_onto_default(target_path, current_branch, default_branch)
+      results << [status, target_path.basename.to_s, status == :skipped ? "already up to date" : ""]
+
+      # === rebase each embedded repo from its source counterpart ===
+
+      embedded_repos(target_path, rebase_repo_paths).each do |wt_repo|
+        rel = wt_repo.relative_path_from(target_path)
+        src_repo = source_root / rel
+
+        unless src_repo.directory? && (src_repo / ".git").exist?
+          Log.warn_ "no source counterpart for #{rel}; skipping"
+          results << [:skipped, rel.to_s, "no source counterpart"]
+          next
+        end
+
+        _, f_err, f_st = Spinner.with_spinner("fetching #{rel}") do
+          Sh.capture3("git", "-C", wt_repo.to_s, "fetch", src_repo.to_s, default_branch)
+        end
+        unless f_st.success?
+          Log.warn_ "git fetch #{src_repo} failed for #{rel}: #{f_err.strip}"
+          results << [:failed, rel.to_s, f_err.strip]
+          next
+        end
+
+        wt_head, _, _ = Sh.capture3("git", "-C", wt_repo.to_s, "rev-parse", "HEAD")
+        fetch_head, _, _ = Sh.capture3("git", "-C", wt_repo.to_s, "rev-parse", "FETCH_HEAD")
+        if wt_head.strip == fetch_head.strip
+          Log.info "skipped #{rel} (up to date)"
+          results << [:skipped, rel.to_s, "already up to date"]
+          next
+        end
+
+        _, r_err, r_st = Spinner.with_spinner("rebasing #{rel}") do
+          Sh.capture3("git", "-C", wt_repo.to_s, "rebase", "FETCH_HEAD")
+        end
+        if r_st.success?
+          Log.info "rebased #{rel}"
+          results << [:ok, rel.to_s, ""]
+        else
+          Log.warn_ "git rebase failed for #{rel}: #{r_err.strip}"
+          results << [:failed, rel.to_s, r_err.strip]
+        end
+      end
+
+      if Log.debug?
+        lines = []
+        lines << ""
+        lines << "=== rebase summary ==="
+        results.each do |status, name, msg|
+          line = "  [#{status.to_s.ljust(7)}] #{name}"
+          line += "  (#{msg})" unless msg.empty?
+          lines << line
+        end
+        lines << ""
+        # Debug-only console report: never write the block to the log file.
+        Log.section(lines.join("\n"), interactive: true, force: force)
+      end
+
+      # === post-rebase hooks ===
+      failed = results.any? { |st, _, _| st == :failed }
+      if !failed && config[:post_rebase_hooks].any?
+        post_rebase_hooks = config[:post_rebase_hooks]
+        post_rebase_hooks.each do |cmd|
+          out = nil
+          if LogFile.enabled?
+            # Console output is already suppressed under --log-file,
+            # so the hook's own stdout/stderr must be captured here —
+            # otherwise a failing hook's real error output (e.g. a
+            # migration stack trace) never reaches the log file at all.
+            out, status = Sh.capture2e(cmd)
+          else
+            status = Spinner.with_spinner("running post-rebase hook: #{cmd}") do
+              Sh.system(cmd)
+              $?
+            end
+          end
+
+          if status.success?
+            Log.info "post-rebase hook completed: #{cmd}"
+            next
+          end
+          detail = out.to_s.strip
+          # A failing hook's output is its diagnostic — show it on the
+          # console in every mode (also already in the log file under
+          # --log-file, where this line surfaces the failure inline).
+          warn detail unless LogFile.enabled?
+          summary = "post-rebase hook failed (exit #{status.exitstatus}): #{cmd}"
+          Log.die detail.empty? ? summary : "#{summary}\n#{detail}"
+        end
+      end
+
+      exit(failed ? 2 : 0)
+    end
+
+    # Rebases current_branch (checked out at target_path) onto the
+    # source's default branch. Returns :skipped if already up to date,
+    # :ok if rebased. Dies (and aborts the rebase) on conflict.
+    def rebase_branch_onto_default(target_path, current_branch, default_branch)
+      _, _, ancestor_st = Sh.capture3("git", "-C", target_path.to_s, "merge-base", "--is-ancestor", default_branch, "HEAD")
+      if ancestor_st.success?
+        Log.info "#{current_branch} already up to date with #{default_branch}"
+        return :skipped
+      end
+
+      _, err, st = Spinner.with_spinner("rebasing #{current_branch} onto #{default_branch}") do
+        Sh.capture3("git", "-C", target_path.to_s, "rebase", default_branch)
+      end
+      if st.success?
+        Log.info "rebased #{current_branch} onto #{default_branch}"
+        :ok
+      else
+        Sh.capture3("git", "-C", target_path.to_s, "rebase", "--abort")
+        Log.die "rebase conflict in #{target_path.basename} — rebase aborted; resolve the conflict manually and re-run ctree rebase"
+      end
+    end
+
+    def working_tree_clean?(path)
+      out, _, st = Sh.capture3("git", "-C", path.to_s, "status", "--porcelain")
+      st.success? && out.strip.empty?
+    end
+
+    # Returns Pathname objects for each immediate subdirectory under each
+    # rebase entry that has a .git entry and is not a submodule.
+    def embedded_repos(root, repo_paths)
+      submodule_relpaths = load_submodule_paths(root)
+      repos = []
+      repo_paths.each do |rel_dir|
+        scan_dir = root / rel_dir
+        next unless scan_dir.directory?
+        scan_dir.children.select(&:directory?).sort.each do |subdir|
+          next unless (subdir / ".git").exist?
+          rel = subdir.relative_path_from(root).to_s
+          next if submodule_relpaths.include?(rel)
+          repos << subdir
+        end
+      end
+      repos
+    end
+
+    def load_submodule_paths(root)
+      gitmodules = root / ".gitmodules"
+      return [] unless gitmodules.file?
+      File.readlines(gitmodules.to_s)
+          .grep(/^\s*path\s*=/)
+          .map { |l| l.split("=", 2).last.strip }
+    end
+
+    private_class_method :working_tree_clean?, :embedded_repos, :load_submodule_paths
+  end
+end

data/lib/ctree/sync.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ctree
+  module Sync
+    module_function
+
+    def run(force: false)
+      begin
+        Ctree::Rebase.run(force: force)
+      rescue SystemExit => e
+        exit e.status unless e.success?
+      end
+
+      Ctree::Update.run(force: force)
+    end
+  end
+end

data/lib/ctree/update.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+module Ctree
+  module Update
+    module_function
+
+    # Runs from INSIDE a worktree. The worktree is a `git worktree` of the
+    # source repo, so the source root is the parent of git's common dir. The
+    # worktree's own .ctree config (on its branch) governs the update.
+    def run(force: false)
+      target_path = Pathname.pwd
+      toplevel_out, _, status = Sh.capture3("git", "-C", target_path.to_s, "rev-parse", "--show-toplevel")
+      Log.die "not inside a git repository" unless status.success?
+      git_top = Pathname.new(toplevel_out.strip)
+      unless target_path.realpath == git_top.realpath
+        Log.die "must be invoked from the worktree top-level (cwd=#{target_path}, top=#{git_top})"
+      end
+
+      # The main worktree (source) lives one level up from the git common dir.
+      common_out, _, c_st = Sh.capture3("git", "-C", target_path.to_s, "rev-parse", "--git-common-dir")
+      Log.die "could not resolve git common dir" unless c_st.success?
+      common = Pathname.new(common_out.strip)
+      common = (target_path / common) unless common.absolute?
+      source_root = common.parent.realpath
+
+      if source_root == target_path.realpath
+        Log.die "already in the source project; run ctree update from inside a worktree"
+      end
+
+      config = Config.load(target_path)
+      Log.debug_mode = config[:log_level] == "debug"
+      Log.log_prefix = config[:log_prefix]
+      share_volumes = config[:share_volumes]
+      update_volumes = config[:update_volumes]
+      empty_volumes = config[:empty_volumes]
+      override_rel = config[:compose_override_file].to_s
+      env_filename = config[:env_filename]
+
+      source_env_vars = EnvFile.parse(source_root / env_filename)
+      env_source_project = source_env_vars["COMPOSE_PROJECT_NAME"]
+      source_project = if env_source_project && !env_source_project.empty?
+                         env_source_project
+                       else
+                         Naming.sanitize_compose_project_name(source_root.basename.to_s)
+                       end
+
+      target_env_vars = EnvFile.parse(target_path / env_filename)
+      env_target_project = target_env_vars["COMPOSE_PROJECT_NAME"]
+      target_project = if env_target_project && !env_target_project.empty?
+                         env_target_project
+                       else
+                         Naming.sanitize_compose_project_name(target_path.basename.to_s)
+                       end
+
+      unless ComposeOverride.valid?(
+        target_path: target_path, override_rel: override_rel,
+        share_volumes: share_volumes, source_project: source_project
+      )
+        Log.die "invalid ctree override file. run 'ctree compose-config fix' to fix"
+      end
+
+      Log.info "updating worktree #{target_path.basename} from #{source_root.basename}"
+      Log.info "worktree:  #{target_path}"
+      Log.info "source:    #{source_root}"
+
+      # === docker preflight ===
+
+      docker_ok = Sh.system("docker", "info", out: File::NULL, err: File::NULL)
+      unless docker_ok
+        Log.warn_ "docker not reachable — skipping update"
+        exit 1
+      end
+
+      src_branch_out, _, _ = Sh.capture3("git", "-C", source_root.to_s, "rev-parse", "--abbrev-ref", "HEAD")
+      src_branch = src_branch_out.strip
+      default_branch = Git.detect_default_branch(source_root)
+      if !src_branch.empty? && src_branch != default_branch
+        Log.warn_ "source repo is on branch '#{src_branch}' (not '#{default_branch}')"
+        unless Prompt.confirm("proceed with update? [y/N]:", default: :no, force: force)
+          Log.info "update aborted"
+          exit 1
+        end
+      end
+
+      src_ps_out, _, src_ps_st = Sh.capture3(
+        "docker", "ps",
+        "--filter", "label=com.docker.compose.project=#{source_project}",
+        "--quiet"
+      )
+      Log.die "docker ps failed" unless src_ps_st.success?
+      unless src_ps_out.strip.empty?
+        Log.warn_ "source compose stack has running containers"
+        if Prompt.confirm("stop source containers before updating? [Y/n]:", default: :yes, force: force)
+          _, err, st = Spinner.with_spinner("stopping source compose stack") do
+            Sh.capture3("docker", "compose", "-p", source_project, "down", chdir: source_root.to_s)
+          end
+          if st.success?
+            Log.info "stopped source compose stack"
+          else
+            Log.die "failed to stop source compose stack: #{err.strip}"
+          end
+        else
+          Log.warn_ "source containers still running; aborting"
+          exit 1
+        end
+      end
+
+      ps_out, _, status = Sh.capture3(
+        "docker", "ps",
+        "--filter", "label=com.docker.compose.project=#{target_project}",
+        "--quiet"
+      )
+      Log.die "docker ps failed" unless status.success?
+      unless ps_out.strip.empty?
+        _, err, st = Spinner.with_spinner("stopping worktree compose stack") do
+          Sh.capture3("docker", "compose", "-p", target_project, "down")
+        end
+        if st.success?
+          Log.info "stopped worktree compose stack"
+        else
+          Log.die "failed to stop worktree compose stack: #{err.strip}"
+        end
+      end
+
+      # === re-tag source images so the worktree picks up freshly built layers ===
+
+      tagged = Images.tag_to_target(source_project, target_project)
+      Log.info "tagged #{tagged.size} docker images" if tagged.any? && !Log.debug?
+
+      # === identify volumes mounted externally from source via override yml ===
+
+      shared_suffixes = share_volumes.dup
+      override_path = override_rel.empty? ? nil : (target_path / override_rel)
+      if override_path&.file?
+        begin
+          override_doc = YAML.safe_load(File.read(override_path.to_s), aliases: true)
+          if override_doc.is_a?(Hash) && override_doc["volumes"].is_a?(Hash)
+            override_doc["volumes"].each do |key, v|
+              next unless v.is_a?(Hash) && v["external"]
+              nm = v["name"]
+              next unless nm.is_a?(String) && !nm.empty?
+              next if nm.start_with?("#{target_project}_")
+              shared_suffixes << key
+            end
+          end
+        rescue Psych::SyntaxError => e
+          Log.warn_ "could not parse #{override_path}: #{e.message}; using only built-in skip list"
+        end
+        shared_suffixes.uniq!
+      end
+
+      vols_out, _, status = Sh.capture3("docker", "volume", "ls", "--format", "{{.Name}}")
+      Log.die "docker volume ls failed" unless status.success?
+      prefix_re = /\A#{Regexp.escape(source_project)}_/
+      source_volumes = vols_out.lines.map(&:strip).reject(&:empty?).select { |v| v =~ prefix_re }
+
+      if source_volumes.empty?
+        Log.info "no source volumes found with prefix '#{source_project}_'"
+      end
+
+      to_sync = []
+      sync_results = []
+      to_skip_buckets = {
+        "not in sync allowlist" => [],
+        "shared from source" => [],
+        "no target volume" => []
+      }
+
+      source_volumes.each do |src_vol|
+        suffix = src_vol.sub(prefix_re, "")
+        tgt_vol = "#{target_project}_#{suffix}"
+
+        if empty_volumes.include?(suffix)
+          sync_results << [src_vol, tgt_vol, :empty, "empty volume"]
+          next
+        end
+
+        if shared_suffixes.include?(suffix)
+          to_skip_buckets["shared from source"] << [src_vol, tgt_vol]
+          next
+        end
+
+        unless update_volumes.include?(suffix)
+          to_skip_buckets["not in sync allowlist"] << [src_vol, tgt_vol]
+          next
+        end
+
+        _, _, st = Sh.capture3("docker", "volume", "inspect", tgt_vol)
+        unless st.success?
+          to_skip_buckets["no target volume"] << [src_vol, tgt_vol]
+          next
+        end
+
+        to_sync << [src_vol, tgt_vol]
+      end
+
+      Volume.ensure_rsync_image! if to_sync.any?
+
+      volume_bytes = 0
+      updated_vol_count = 0
+
+      to_sync.each do |src_vol, tgt_vol|
+        st, err, bytes = Volume.rsync_with_progress(src_vol, tgt_vol)
+        if st.success?
+          volume_bytes += bytes.to_i
+          updated_vol_count += 1
+          sync_results << [src_vol, tgt_vol, :updated, ""]
+        else
+          Log.warn_ "rsync failed for #{tgt_vol}: #{err.strip}"
+          sync_results << [src_vol, tgt_vol, :failed, "rsync failed: #{err.strip}"]
+        end
+      end
+
+      ["not in sync allowlist", "shared from source", "no target volume"].each do |reason|
+        to_skip_buckets[reason].each do |src_vol, tgt_vol|
+          Log.debug "skipped #{src_vol} (#{reason})"
+          sync_results << [src_vol, tgt_vol, :skipped, reason]
+        end
+      end
+
+      if updated_vol_count > 0
+        Log.info "updated #{updated_vol_count} volume#{updated_vol_count == 1 ? "" : "s"}#{Sizes.note(volume_bytes)}" unless Log.debug?
+      end
+
+      sync_file_results = []
+      updated_file_count = 0
+      file_bytes = 0
+      config[:update].each do |rel|
+        if !override_rel.empty? && rel == override_rel
+          Log.debug "skipped #{rel} (compose override file managed by ctree create)"
+          sync_file_results << [rel, :skipped, "compose override file"]
+          next
+        end
+        if rel == ".ctree" || rel.start_with?(".ctree/")
+          Log.debug "skipped #{rel} (reserved directory managed by ctree create)"
+          sync_file_results << [rel, :skipped, "reserved directory"]
+          next
+        end
+        src = source_root / rel
+        tgt = target_path / rel
+        if src.directory?
+          FileUtils.mkdir_p(tgt.to_s)
+          _, err, st = Spinner.with_spinner("rsync #{rel}/") do
+            Sh.capture3("rsync", "-a", "--checksum", "--delete", "#{src}/", "#{tgt}/")
+          end
+          if st.success?
+            bytes = Sizes.path_bytes(src)
+            Log.debug "updated #{rel}/#{Sizes.note(bytes)}"
+            file_bytes += bytes
+            updated_file_count += 1
+            sync_file_results << [rel, :updated, ""]
+          else
+            Log.warn_ "rsync failed for #{rel}: #{err.strip}"
+            sync_file_results << [rel, :failed, "rsync failed: #{err.strip}"]
+          end
+        elsif src.file?
+          _, err, st = Spinner.with_spinner("rsync #{rel}") do
+            Sh.capture3("rsync", "-a", "--checksum", src.to_s, tgt.to_s)
+          end
+          if st.success?
+            bytes = Sizes.path_bytes(src)
+            Log.debug "updated #{rel}#{Sizes.note(bytes)}"
+            file_bytes += bytes
+            updated_file_count += 1
+            sync_file_results << [rel, :updated, ""]
+          else
+            Log.warn_ "rsync failed for #{rel}: #{err.strip}"
+            sync_file_results << [rel, :failed, "rsync failed: #{err.strip}"]
+          end
+        else
+          Log.warn_ "update: source not found: #{rel}"
+          sync_file_results << [rel, :missing, "source not found"]
+        end
+      end
+      if updated_file_count > 0 && !Log.debug?
+        Log.info "updated #{updated_file_count} file#{updated_file_count == 1 ? "" : "s"}#{Sizes.note(file_bytes)}"
+      end
+
+      failed = sync_results.any? { |_, _, st, _| st == :failed } ||
+               sync_file_results.any? { |_, st, _| st == :failed }
+
+      post_update_hooks = config[:post_update_hooks]
+      unless post_update_hooks.empty?
+        post_update_hooks.each_with_index do |cmd, idx|
+          label = "post-update hook #{idx + 1}/#{post_update_hooks.size}"
+          out = nil
+          if LogFile.enabled?
+            # Console output is already suppressed under --log-file
+            # (Log.info/Log.warn_ route to the file only), so the hook's
+            # own stdout/stderr must be captured here — otherwise a
+            # failing hook's real error output (e.g. a migration stack
+            # trace) never reaches the log file at all.
+            out, status = Sh.capture2e(cmd)
+          else
+            status = Spinner.with_progress("running #{label}: #{cmd}") do
+              Sh.system(cmd)
+              $?
+            end
+          end
+
+          detail = out.to_s.strip
+          Log.info detail unless detail.empty?
+          if status.success?
+            next
+          end
+
+          # A failing hook's output is its diagnostic — show it on the
+          # console in every mode (also already in the log file under
+          # --log-file, where this line surfaces the failure inline).
+          warn detail unless LogFile.enabled?
+          summary = "post-update hook failed (exit #{status.exitstatus}): #{cmd}"
+          Log.die detail.empty? ? summary : "#{summary}\n#{detail}"
+        end
+      end
+
+      if Log.debug?
+        lines = []
+        lines << ""
+        lines << "=== update summary ==="
+        lines << "worktree:  #{target_path}"
+
+        if sync_results.any?
+          lines << "volumes:"
+          sync_results.each do |src, tgt, st, msg|
+            line = "  [#{st.to_s.ljust(7)}] #{src}  ->  #{tgt}"
+            line += "  (#{msg})" unless msg.to_s.empty?
+            lines << line
+          end
+        end
+
+        if sync_file_results.any?
+          lines << "files/dirs:"
+          sync_file_results.each do |rel, st, msg|
+            line = "  [#{st.to_s.ljust(7)}] #{rel}"
+            line += "  (#{msg})" unless msg.to_s.empty?
+            lines << line
+          end
+        end
+
+        if post_update_hooks.any?
+          lines << "post-update hooks:"
+          post_update_hooks.each do |cmd|
+            lines << "  [ran    ] #{cmd}"
+          end
+        end
+
+        # Debug-only console report: never write the block to the log file.
+        Log.section(lines.join("\n"), interactive: true, force: force)
+      end
+
+      exit(failed ? 2 : 0)
+    end
+  end
+end