refactorai-cli 0.4.10__tar.gz → 0.4.12__tar.gz

{refactorai_cli-0.4.10 → refactorai_cli-0.4.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.4.10
+Version: 0.4.12
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,7 +8,7 @@ Requires-Dist: typer>=0.12.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: PyYAML>=6.0.1
-Requires-Dist: refactorai-core>=3.2.5
+Requires-Dist: refactorai-core>=3.2.7
 
 # refactorai-cli
 

{refactorai_cli-0.4.10 → refactorai_cli-0.4.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.4.10"
+version = "0.4.12"
 description = "Local-first CLI for the refactor platform"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,7 +12,7 @@ dependencies = [
   "httpx>=0.27.0",
   "rich>=13.7.0",
   "PyYAML>=6.0.1",
-  "refactorai-core>=3.2.5",
+  "refactorai-core>=3.2.7",
 ]
 
 [project.scripts]

{refactorai_cli-0.4.10 → refactorai_cli-0.4.12}/refactorai_cli/__init__.py

@@ -5,4 +5,4 @@ the shared `refactor_core` pipeline from a project folder while staying
 authenticated to the hosted platform via a developer key.
 """
 
-__version__ = "0.4.10"
+__version__ = "0.4.12"

{refactorai_cli-0.4.10 → refactorai_cli-0.4.12}/refactorai_cli/cloud_rr.py

@@ -651,6 +651,7 @@ def run_cloud_refactor_requests(
     apply_byok_payload: Callable[[dict, object], None] | None = None,
     toolchain_consent_cb: Callable[[dict], bool] | None = None,
     commit_cb: Callable[[object], None] | None = None,
+    on_rr_failure: str = "continue",
 ) -> RunArtifact:
     """Drive pending RRs through the cloud server-run loop and return a summary.
 
@@ -665,6 +666,12 @@ def run_cloud_refactor_requests(
     once per RR that reaches ``APPLIED`` so the CLI can record one git commit per
     resolved request on an isolated refactor branch. Best-effort; git failures
     never break the cloud RR loop.
+
+    ``on_rr_failure`` (``continue`` | ``defer`` | ``stop``) mirrors the local
+    executor policy and is forwarded to the server so a single failing RR no
+    longer halts the whole run by default (parity with local). The client stays a
+    thin executor: it stops only when the server returns a ``failed`` verdict with
+    no ``next_rr_id`` (older servers that always stop remain compatible).
     """
     project_root = Path(project_root)
     progress_cb = progress_cb or (lambda e: None)
@@ -741,6 +748,7 @@ def run_cloud_refactor_requests(
         "constitution_hash": constitution.content_hash,
         "constitution_body": getattr(constitution, "body", "") or "",
         "model_hint": resolved_model,
+        "on_rr_failure": str(on_rr_failure or "continue"),
         "rrs": [
             {
                 "rr_id": rr.rr_id,
@@ -875,12 +883,17 @@ def run_cloud_refactor_requests(
                 attempts_by_id.get(completed_id, 0 if verdict == "deferred" else 1),
                 outcomes, counts, progress_cb, commit_cb=commit_cb,
             )
-            if verdict == "failed":
+            next_id = str(action.get("next_rr_id", "") or "")
+            # With `continue`/`defer` (the default) the server advances after a
+            # failure, so the client resolves the remaining requests in one pass
+            # instead of stopping at the first failure (parity with local). Only a
+            # `stop` policy halts the run (no next RR named); a failed *last* RR
+            # under `continue` simply ends the queue, it is not a halt.
+            if verdict == "failed" and not next_id and str(on_rr_failure) == "stop":
                 stopped = True
                 stop_reason = str(action.get("message", "") or "refactor request failed")
                 _emit(progress_cb, phase="rr", event="run_stopped", rr_id=completed_id, reason=stop_reason)
                 break
-            next_id = str(action.get("next_rr_id", "") or "")
             if not next_id:
                 break
             current_rr_id = next_id

{refactorai_cli-0.4.10 → refactorai_cli-0.4.12}/refactorai_cli/commands/branch_cmds.py

@@ -128,6 +128,9 @@ def merge_branch(
     ok, output = git_scope.merge(project_root, target, squash=squash)
     if not ok:
         return False, f"merge failed / conflicted: {output}"
+    # docs/43 `R30`: remember the terminal outcome so the finalize view can render
+    # a DONE (merged) node without re-inspecting git.
+    refactor_branch_store.set_outcome(project_root, target, refactor_branch_store.OUTCOME_MERGED)
     if squash:
         sha = git_scope.commit(project_root, _squash_message(project_root, target, source))
         if not sha:

{refactorai_cli-0.4.10 → refactorai_cli-0.4.12}/refactorai_cli/commands/run_cmds.py

@@ -2955,7 +2955,19 @@ def code(
         changed=changed,
         intent=intent,
     )
-    _confirm_full_project_scope(code_scope, command="code", assume_yes=yes_full_project)
+    # Decide reuse-vs-generate up front. The full-project confirmation only guards
+    # *creating* a large request set; when we are resolving an existing pending
+    # queue (the common `[r]` resume case) there is nothing to confirm, so a root
+    # commit no longer re-prompts every run (docs/42 `R29`, Part L).
+    reused_requests = [] if (code_scope and refresh_requests) else pending_requests(project_root)
+    will_generate_requests = bool(refresh_requests) or not reused_requests
+    if will_generate_requests:
+        _confirm_full_project_scope(code_scope, command="code", assume_yes=yes_full_project)
+    elif code_scope and code_scope.get("full_project"):
+        console.print(
+            f"[dim]code: resuming {len(reused_requests)} pending request(s) for this "
+            "commit (full-project review already ran).[/dim]"
+        )
     code_scope_paths = code_scope.get("scope_paths") if code_scope else None
     code_changed_paths = code_scope.get("changed_paths") if code_scope else None
     if code_scope:
@@ -3043,11 +3055,9 @@ def code(
         # Reuse the existing pending requests by default (docs/42 `R29`, Phase 1):
         # `[r]`/`code --commit` resolves the queue already created for this commit
         # rather than regenerating it. `--refresh-requests` opts back into a fresh
-        # scoped review so the request set is rebuilt from scratch.
-        if code_scope and refresh_requests:
-            requests = []
-        else:
-            requests = pending_requests(project_root)
+        # scoped review so the request set is rebuilt from scratch. Computed above
+        # (``reused_requests``) so the full-project prompt could be skipped on reuse.
+        requests = reused_requests
         if not requests:
             if code_scope and refresh_requests:
                 console.print(
@@ -3169,6 +3179,7 @@ def code(
                     apply_byok_payload=_apply_byok_payload,
                     toolchain_consent_cb=_toolchain_consent_prompt(auto_approve=auto_approve),
                     commit_cb=rr_commit_cb,
+                    on_rr_failure=on_rr_failure,
                 )
         else:
             # Local mode is unchanged: dispatch to the local executor with the
@@ -3217,6 +3228,16 @@ def code(
         final_status = "skipped"
         if _final_test_enabled(project_config):
             final_status, _ = _run_final_test_suite(project_root, project_config)
+        # docs/43 `R30`: persist the verdict so the Refactor Terminal finalize view
+        # can show it without re-running the suite.
+        try:
+            from refactorai_cli import refactor_branch_store
+
+            refactor_branch_store.set_final_test(
+                project_root, refactor_branch_ctx.get("branch_name", ""), final_status
+            )
+        except Exception:
+            pass
         decision = _decide_finalize(
             project_config,
             finalize=finalize,

{refactorai_cli-0.4.10 → refactorai_cli-0.4.12}/refactorai_cli/commands/watch_cmds.py

@@ -25,10 +25,15 @@ from typing import Callable
 import typer
 from rich.console import Console
 
-from refactorai_cli import commit_queue, git_scope, watch_state
+from refactorai_cli import commit_queue, git_scope, refactor_branch_store, watch_state
 from refactorai_cli.auth import AuthError, ensure_authenticated
 from refactorai_cli.review_runner import ReviewRunner, SubprocessReviewRunner
-from refactorai_cli.watch_state import WatchState, render_graph
+from refactorai_cli.watch_state import (
+    FinalizeInfo,
+    RRCommit,
+    WatchState,
+    render_graph,
+)
 
 console = Console()
 
@@ -121,6 +126,141 @@ def _pending_for_run(
     return len(matches), lines
 
 
+# --------------------------------------------------------------------------- #
+# Finalize / branch-view resolution (docs/43 `R30`, Phase 1)                    #
+# --------------------------------------------------------------------------- #
+
+def _shas_match(a: str, b: str) -> bool:
+    """True if two shas refer to the same commit (tolerant of short/long forms)."""
+    a = str(a or "")
+    b = str(b or "")
+    if not a or not b:
+        return False
+    return a == b or a.startswith(b) or b.startswith(a)
+
+
+def _resolve_refactor_branch(
+    project_root: Path, node
+) -> tuple[str, "refactor_branch_store.BranchMeta | None"]:
+    """Map a commit node to its refactor branch (docs/43 Part C).
+
+    Resolution order: (1) a branch-store entry whose ``source_sha`` matches the
+    node, (2) the ``refactor/<branch>/<shortsha>`` name template, (3) an RR
+    record carrying ``refactor_branch`` for this node's run. Returns
+    ``("", None)`` when nothing links the node to a refactor branch.
+    """
+    # 1) recorded source association (reversible, preferred).
+    for meta in refactor_branch_store.list_branches(project_root):
+        if meta.source_sha and _shas_match(node.sha, meta.source_sha):
+            return meta.branch, meta
+    # 2) deterministic name template from the node's branch + sha.
+    template = refactor_branch_store.refactor_branch_name(node.branch, node.sha)
+    meta = refactor_branch_store.load_branch(project_root, template)
+    if meta is not None or git_scope.branch_exists(project_root, template):
+        return template, meta
+    # 3) RR records created by this node's run.
+    branch = _branch_from_run(project_root, getattr(node, "run_id", ""))
+    if branch:
+        return branch, refactor_branch_store.load_branch(project_root, branch)
+    return "", None
+
+
+def _branch_from_run(project_root: Path, run_id: str) -> str:
+    """First ``refactor_branch`` recorded on an RR created by ``run_id``."""
+    if not run_id:
+        return ""
+    try:
+        from refactor_core.refactor_requests import list_requests
+    except Exception:
+        return ""
+    try:
+        requests = list_requests(project_root)
+    except Exception:
+        return ""
+    for rr in requests:
+        if str(getattr(rr, "created_by_run", "") or "") == run_id:
+            branch = str(getattr(rr, "refactor_branch", "") or "")
+            if branch:
+                return branch
+    return ""
+
+
+def _rr_commits_for_branch(
+    project_root: Path, branch: str, *, run_id: str = ""
+) -> list[RRCommit]:
+    """Per-request commits recorded on ``branch`` (newest first)."""
+    if not branch:
+        return []
+    try:
+        from refactor_core.refactor_requests import list_requests
+    except Exception:
+        return []
+    try:
+        requests = list_requests(project_root)
+    except Exception:
+        return []
+    out: list[RRCommit] = []
+    for rr in requests:
+        rr_branch = str(getattr(rr, "refactor_branch", "") or "")
+        commit_sha = str(getattr(rr, "commit_sha", "") or "")
+        if not commit_sha:
+            continue
+        # Prefer an exact branch match; fall back to the node's run when the RR
+        # predates branch tagging.
+        if rr_branch == branch or (not rr_branch and run_id and str(getattr(rr, "created_by_run", "") or "") == run_id):
+            out.append(
+                RRCommit(
+                    rr_id=str(getattr(rr, "rr_id", "") or ""),
+                    commit_sha=commit_sha,
+                    location=str(getattr(rr, "location", "") or ""),
+                    status=str(getattr(rr, "status", "") or ""),
+                    reverted=bool(getattr(rr, "reverted", False)),
+                )
+            )
+    # ``list_requests`` is oldest-first; newest RR commit renders on top.
+    out.reverse()
+    return out
+
+
+def resolve_finalize(project_root: Path, node) -> FinalizeInfo | None:
+    """Resolve the finalize/branch-view data for a node (docs/43 Part C/G).
+
+    Returns ``None`` when the node has no refactor branch to finalize. Fail-soft:
+    any store/git hiccup yields ``None`` rather than raising into the terminal.
+    """
+    try:
+        branch, meta = _resolve_refactor_branch(project_root, node)
+    except Exception:
+        return None
+    if not branch:
+        return None
+    try:
+        exists = git_scope.branch_exists(project_root, branch)
+    except Exception:
+        exists = False
+    commits = _rr_commits_for_branch(project_root, branch, run_id=getattr(node, "run_id", ""))
+    outcome = meta.outcome if meta else ""
+    # Nothing to show and nothing recorded -> treat as "no finalize".
+    if not commits and not exists and not outcome:
+        return None
+    return FinalizeInfo(
+        refactor_branch=branch,
+        source_branch=(meta.source_branch if meta else "") or node.branch,
+        source_sha=(meta.source_sha if meta else "") or node.sha,
+        branch_exists=exists,
+        outcome=outcome,
+        final_test=meta.final_test if meta else "",
+        commits=commits,
+    )
+
+
+def refresh_finalize(project_root: Path, state: WatchState) -> None:
+    """Recompute finalize data for reviewed nodes so phases stay current."""
+    for node in state.nodes_oldest_first():
+        if node.state == watch_state.REVIEWED:
+            node.finalize = resolve_finalize(project_root, node)
+
+
 def _resolve_repo(project_root: Path | None) -> Path:
     root = git_scope.repo_root(project_root or Path.cwd())
     if not root:
@@ -184,6 +324,11 @@ def process_pending(
     (rendering happens via ``on_update``) so it is unit-testable with a fake
     runner and a temporary queue file.
     """
+    # Track the checked-out branch so the finalize view can mark "(current)".
+    try:
+        state.current_branch = git_scope.current_branch(project_root) or state.current_branch
+    except Exception:
+        pass
     for event in commit_queue.read_events(project_root):
         sha = str(event.get("sha") or "")
         if sha and not state.has(sha):
@@ -210,6 +355,11 @@ def process_pending(
         reviewed += 1
         if on_update:
             on_update(state)
+    # docs/43 Phase 1: fold current refactor-branch data into reviewed nodes so
+    # their phase (review/finalize/done) reflects any branch built by `[r]`.
+    refresh_finalize(project_root, state)
+    if on_update:
+        on_update(state)
     return reviewed
 
 
@@ -258,31 +408,61 @@ def _read_key(timeout: float) -> str:
         termios.tcsetattr(fd, termios.TCSADRAIN, old)
 
 
-def build_action_command(action: str, sha: str, *, executable: str = "refactor") -> list[str] | None:
-    """Build the argv for a terminal action. Pure + testable (docs/42 Phase 4).
-
-    ``code`` reuses pending requests; ``refresh`` regenerates them. Both pass
-    ``--keep`` so resolving from the terminal only *builds* the refactor branch
-    (per-request commits + final test) and never pops its own merge/keep/drop
-    prompt — the terminal's ``[m]`` merge / ``[x]`` drop keys are the single,
-    explicit place that decision is made. ``merge`` / ``drop`` operate on that
-    already-built refactor branch (local only, never pushes).
+def build_action_command(
+    action: str,
+    sha: str,
+    *,
+    executable: str = "refactor",
+    branch: str | None = None,
+    rr_id: str | None = None,
+    yes_full_project: bool = False,
+) -> list[str] | None:
+    """Build the argv for a terminal action. Pure + testable (docs/42, docs/43).
+
+    Review phase (docs/41): ``code`` reuses pending requests; ``refresh``
+    regenerates them. Both pass ``--keep`` so resolving from the terminal only
+    *builds* the refactor branch and never pops its own merge/keep/drop prompt —
+    the finalize phase's ``[m]``/``[x]`` are the single, explicit place that
+    decision is made.
+
+    Finalize phase (docs/43): ``merge``/``drop`` target this commit's refactor
+    ``branch`` (scoped with ``--branch`` when known so a multi-commit terminal is
+    unambiguous); ``revert`` reverses a single ``rr_id``. All are local only.
     """
     if action == "code":
         # Commit-scoped so `[r]` resolves THIS commit's requests (docs/41 Phase 4).
-        return [executable, "code", "--commit", sha, "--keep"]
+        cmd = [executable, "code", "--commit", sha, "--keep"]
+        if yes_full_project:
+            # Root/full-scope commits would otherwise pop a hidden confirmation in
+            # the suspended terminal; auto-confirm so `[r]` never appears to hang.
+            cmd.append("--yes-full-project")
+        return cmd
     if action == "refresh":
         # `[f]` regenerates the requests for this commit before resolving.
-        return [executable, "code", "--commit", sha, "--refresh-requests", "--keep"]
+        cmd = [executable, "code", "--commit", sha, "--refresh-requests", "--keep"]
+        if yes_full_project:
+            cmd.append("--yes-full-project")
+        return cmd
     if action == "diff":
         # Shows the pending refactor-request patch diffs (not the git diff).
         return [executable, "diff"]
     if action == "merge":
         # `[m]` merges this commit's refactor branch into your working branch.
-        return [executable, "branch", "merge"]
+        cmd = [executable, "branch", "merge"]
+        if branch:
+            cmd += ["--branch", branch]
+        return cmd
     if action == "drop":
         # `[x]` discards this commit's refactor branch and its commits.
-        return [executable, "branch", "drop"]
+        cmd = [executable, "branch", "drop"]
+        if branch:
+            cmd += ["--branch", branch]
+        return cmd
+    if action == "revert":
+        # `[v]` reverses one resolved request via `git revert` (docs/42).
+        if not rr_id:
+            return None
+        return [executable, "request", "revert", "--id", rr_id]
     return None
 
 
@@ -304,7 +484,7 @@ def _run_json_stream(project_root: Path, state: WatchState, runner: ReviewRunner
 
     def emit(st: WatchState) -> None:
         for node in st.nodes_oldest_first():
-            signature = f"{node.state}:{node.gate_status}:{node.rr_count}"
+            signature = f"{node.state}:{node.phase}:{node.gate_status}:{node.rr_count}"
             if emitted.get(node.sha) != signature:
                 emitted[node.sha] = signature
                 sys.stdout.write(json.dumps({"type": "node", "node": node.to_contract()}) + "\n")
@@ -317,9 +497,30 @@ def _run_json_stream(project_root: Path, state: WatchState, runner: ReviewRunner
         time.sleep(_POLL_SECONDS)
 
 
-def _run_action(live, project_root: Path, action: str, node, state: WatchState) -> None:
+def _sync_current_branch(project_root: Path, state: WatchState) -> None:
+    try:
+        state.current_branch = git_scope.current_branch(project_root) or state.current_branch
+    except Exception:
+        pass
+
+
+def _run_action(
+    live,
+    project_root: Path,
+    action: str,
+    node,
+    state: WatchState,
+    *,
+    rr_id: str | None = None,
+) -> None:
     """Suspend the live graph, run an interactive action, then refresh the node."""
-    cmd = build_action_command(action, node.sha)
+    branch = node.finalize.refactor_branch if getattr(node, "finalize", None) else None
+    # Root/full-scope commits expand `code` to a full-project review; auto-confirm
+    # so `[r]`/`[f]` never stall on a hidden prompt in the suspended terminal.
+    yes_full_project = getattr(node, "scope_mode", "") == "full"
+    cmd = build_action_command(
+        action, node.sha, branch=branch, rr_id=rr_id, yes_full_project=yes_full_project
+    )
     if not cmd:
         return
     live.stop()
@@ -328,21 +529,134 @@ def _run_action(live, project_root: Path, action: str, node, state: WatchState)
     _launch_interactive(cmd, project_root)
     if action == "refresh":
         # `[f]` explicitly regenerates requests, so re-review this commit on the
-        # next pass.
+        # next pass (also clears any `[b] back` override).
         state.requeue(node.sha)
     elif action == "code":
         # `[r]` is resolve/reuse. Do NOT auto re-review here (that can regenerate
         # duplicate-looking findings); instead reflect current pending requests
-        # from the existing run in-place.
+        # from the existing run in-place, then fold in the refactor branch so the
+        # node auto-transitions to the finalize view (docs/43 FR-02).
+        state.forced_review.discard(node.sha)
         node_after = state.get(node.sha)
         if node_after and node_after.run_id:
             pending_count, preview = _pending_for_run(project_root, node_after.run_id)
             node_after.rr_count = pending_count
             node_after.rr_preview = preview
+        _sync_current_branch(project_root, state)
+        refresh_finalize(project_root, state)
+    elif action in ("merge", "drop", "revert"):
+        # Finalize actions (docs/43). `merge_branch` records the merged outcome
+        # itself; a completed drop leaves no branch, so tombstone the dropped
+        # outcome here so the node collapses to a DONE (dropped) row.
+        if action == "drop" and branch and not git_scope.branch_exists(project_root, branch):
+            refactor_branch_store.set_outcome(project_root, branch, refactor_branch_store.OUTCOME_DROPPED)
+        _sync_current_branch(project_root, state)
+        refresh_finalize(project_root, state)
+    console.print("\n[dim]watch: returning to the Refactor Terminal...[/dim]")
+    live.start()
+
+
+def _run_revert_action(live, project_root: Path, node, state: WatchState) -> None:
+    """`[v]`: pick one resolved request and reverse it via `refactor request revert`."""
+    fin = getattr(node, "finalize", None)
+    commits = [c for c in (fin.commits if fin else []) if not c.reverted]
+    if not commits:
+        console.print("[dim]watch: no revertible requests on this refactor branch.[/dim]")
+        return
+    live.stop()
+    console.print("\n[bold bright_cyan]watch:[/bold bright_cyan] revert a refactor request "
+                  f"on [cyan]{fin.refactor_branch}[/cyan]\n")
+    for idx, commit in enumerate(commits, start=1):
+        console.print(
+            f"  [bold]{idx}[/bold]. {commit.location or '(unknown)'}  "
+            f"[dim](rr {commit.rr_id[:7]}, {(commit.commit_sha or '')[:8]})[/dim]"
+        )
+    try:
+        raw = typer.prompt("Number to revert (blank to cancel)", default="")
+    except (typer.Abort, EOFError, KeyboardInterrupt):
+        raw = ""
+    choice = str(raw).strip()
+    if choice:
+        try:
+            idx = int(choice)
+        except ValueError:
+            idx = 0
+        if 1 <= idx <= len(commits):
+            rr_id = commits[idx - 1].rr_id
+            _launch_interactive(
+                build_action_command("revert", node.sha, rr_id=rr_id), project_root
+            )
+            refresh_finalize(project_root, state)
+        else:
+            console.print("[dim]watch: nothing reverted (out of range).[/dim]")
+    else:
+        console.print("[dim]watch: revert cancelled.[/dim]")
     console.print("\n[dim]watch: returning to the Refactor Terminal...[/dim]")
     live.start()
 
 
+def _dispatch_key(live, project_root: Path, key: str, state: WatchState) -> None:
+    """Route a hotkey to the right action for the selected node's phase (docs/43).
+
+    Finalize phase offers ``[m]/[x]/[d]/[v]/[b]`` (review keys are hidden);
+    review/none/done offers ``[r]/[f]/[d]`` (and ``[b]`` toggles back to a
+    finalize node the user pressed ``[b]`` on).
+    """
+    node = state.selected()
+    if node is None:
+        return
+
+    if state.show_finalize(node):
+        # --- finalize phase: merge / drop / diff / revert / back -------------- #
+        if key == "m":
+            _run_action(live, project_root, "merge", node, state)
+        elif key == "x":
+            _run_action(live, project_root, "drop", node, state)
+        elif key == "d":
+            _run_action(live, project_root, "diff", node, state)
+        elif key == "v":
+            _run_revert_action(live, project_root, node, state)
+        elif key == "b":
+            # Show the review view for this commit so `[f]` fresh review is possible.
+            state.forced_review.add(node.sha)
+        elif key in ("r", "f"):
+            console.print(
+                "[dim]watch: this commit is resolved; press [b] to go back and "
+                "re-review, or [m] to merge.[/dim]"
+            )
+        return
+
+    # --- review / none / done phase ----------------------------------------- #
+    if key == "b" and node.sha in state.forced_review:
+        # Toggle back to the finalize view for a node we forced into review.
+        state.forced_review.discard(node.sha)
+        return
+    if key in ("r", "f", "d"):
+        can_review = node.phase == watch_state.PHASE_REVIEW or node.sha in state.forced_review
+        if key == "d":
+            if node.state == watch_state.REVIEWED:
+                _run_action(live, project_root, "diff", node, state)
+            return
+        if not can_review:
+            console.print(
+                f"[dim]watch: nothing to review on {node.short_sha} "
+                f"(phase: {node.phase}).[/dim]"
+            )
+            return
+        if node.state == watch_state.REVIEWED:
+            _run_action(live, project_root, "code" if key == "r" else "refresh", node, state)
+        else:
+            console.print(
+                f"[dim]watch: {node.short_sha} is '{node.state}'; "
+                "wait for review to finish before acting.[/dim]"
+            )
+    elif key in ("m", "x", "v"):
+        console.print(
+            "[dim]watch: finalize actions apply after this commit's requests are "
+            "resolved onto a refactor branch (press [r]).[/dim]"
+        )
+
+
 def _run_tui(project_root: Path, state: WatchState, runner: ReviewRunner) -> None:
     """Render the live Graphite-style graph and consume the queue serially."""
     from refactorai_cli.main import _print_agent_intro
@@ -370,26 +684,12 @@ def _run_tui(project_root: Path, state: WatchState, runner: ReviewRunner) -> Non
                 state.move_selection(-1)
             elif key in ("down", "j"):
                 state.move_selection(+1)
-            elif key in ("r", "f", "d", "m", "x"):
-                action = {
-                    "r": "code",
-                    "f": "refresh",
-                    "d": "diff",
-                    "m": "merge",
-                    "x": "drop",
-                }[key]
-                node = state.selected()
-                if node and node.state == watch_state.REVIEWED:
-                    _run_action(live, project_root, action, node, state)
-                elif node:
-                    console.print(
-                        f"[dim]watch: {node.short_sha} is '{node.state}'; "
-                        "wait for review to finish before acting.[/dim]"
-                    )
             elif key == "p":
                 console.print(
                     "[dim]watch: push arrives in Phase 5; use `git push` for now.[/dim]"
                 )
+            elif key in ("r", "f", "d", "m", "x", "v", "b"):
+                _dispatch_key(live, project_root, key, state)
             refresh(state)
     finally:
         live.stop()
@@ -418,6 +718,10 @@ def watch(
     _ensure_auth_in_window(json_output)
 
     state = WatchState(repo_name=project_root.name)
+    try:
+        state.current_branch = git_scope.current_branch(project_root) or ""
+    except Exception:
+        state.current_branch = ""
     for event in _load_initial_events(project_root, since, limit):
         sha = str(event.get("sha") or "")
         if sha and not state.has(sha):