code-coordinator 0.5.135__tar.gz → 0.5.136__tar.gz

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.135
+Version: 0.5.136
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.135
+Version: 0.5.136
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/code_coordinator.egg-info/SOURCES.txt

@@ -477,6 +477,7 @@ tests/test_cli_assign_provider.py
 tests/test_cli_assign_repo_drift_2219.py
 tests/test_cli_audit.py
 tests/test_cli_chat_continue.py
+tests/test_cli_decide.py
 tests/test_cli_diagnose_config_provenance.py
 tests/test_cli_diagnose_graph.py
 tests/test_cli_doctor.py

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/code_coordinator.egg-info/scm_file_list.json

@@ -519,6 +519,7 @@
     "tests/test_cli_assign_repo_drift_2219.py",
     "tests/test_cli_audit.py",
     "tests/test_cli_chat_continue.py",
+    "tests/test_cli_decide.py",
     "tests/test_cli_diagnose_config_provenance.py",
     "tests/test_cli_diagnose_graph.py",
     "tests/test_cli_doctor.py",

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.135",
+  "tag": "0.5.136",
   "distance": 0,
-  "node": "g9359f42f1ecf543611d7068c3cd4cc7644804eb4",
+  "node": "g44c61fdca127a9fd4f56bc83b75d60e32e623366",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-18"

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/coord/cli.py

@@ -130,6 +130,7 @@ from coord.commands.issues import (
     untrack,
 )
 from coord.commands.drive import (
+    decide,
     drive,
     drive_attach,
     drive_sessions,
@@ -462,6 +463,7 @@ main.add_command(drive_attach)
 main.add_command(drive_stop)
 main.add_command(drive_queue_group)
 main.add_command(escalate_group)
+main.add_command(decide)
 main.add_command(pr)
 main.add_command(fix)
 main.add_command(review)

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/coord/commands/drive.py

@@ -664,3 +664,109 @@ def escalate_run(repo: str, issue: int, dismiss: bool, config_path: Path) -> Non
     if dismiss:
         dismiss_drive_escalation(repo, issue)
     click.echo("done")
+
+
+# ── coord decide (#2370) ──────────────────────────────────────────────────
+#
+# `escalate run` above only ever executes ONE thing — the single
+# `proposed_command` a `drive_escalations` row carries — because that's all
+# that source has. The `decisions` report (#2369) folds a SECOND source in
+# too (drive-queue `blocked`/`failed` rows with no escalation record at
+# all) and renders 2-4 *options* per card, not one, with no "run it" path
+# for either source. `decide` generalizes `escalate run`'s one-key pattern
+# to both sources and to any option on the card, not just the recommended
+# one — it does NOT replace `escalate run`/`dismiss`/`list`, which keep
+# working exactly as before.
+
+
+@click.command("decide")
+@click.argument("repo")
+@click.argument("issue", type=int)
+@click.argument("option_index", type=int, required=False, default=None)
+@click.option(
+    "--dismiss/--no-dismiss", default=True,
+    help=(
+        "Clear the drive_escalations record after a zero exit, IF the chosen "
+        "option is that record's own proposed fix (default: yes). Has no "
+        "effect otherwise — there is no record to dismiss for a non-default "
+        "option or a drive-queue-only card; see the command's docstring."
+    ),
+)
+@_CONFIG_OPTION
+def decide(
+    repo: str,
+    issue: int,
+    option_index: int | None,
+    dismiss: bool,
+    config_path: Path,
+) -> None:
+    """Run one option from REPO ISSUE's `decisions` report card.
+
+    OPTION_INDEX is the 0-based index into that card's `options` list
+    (default: the card's `recommended` option). The row is looked up fresh
+    from `coord.reports.find_decision` every call — `decide` never re-derives
+    or caches its own copy of "what the options are"; it runs exactly the
+    `command_or_action` string the `decisions` report would show for that
+    slot, via the same `subprocess.run(command, shell=True)` primitive
+    `escalate run` uses.
+
+    Post-run bookkeeping differs by what the card is backed by:
+
+    \b
+    - A card folded from a `drive_escalations` row (#1505), when the chosen
+      option is that row's `proposed_command` (i.e. no OPTION_INDEX given,
+      or OPTION_INDEX 0): behaves exactly like `coord escalate run` —
+      dismiss the record on a zero exit (--dismiss/--no-dismiss).
+    - Anything else — a non-default option on an escalation card, or ANY
+      option on a drive-queue-only card (#2283/coord-portal#107, no
+      escalation record exists for these): there is nothing to dismiss.
+      `decide` echoes success/failure and stops; the card's own
+      reappearance-or-not on the next `coord report run decisions` is the
+      confirmation signal, not a second "resolved" state that could go
+      stale or lie.
+    """
+    from coord.reports import find_decision  # noqa: PLC0415
+    from coord.state import dismiss_drive_escalation  # noqa: PLC0415
+
+    card = find_decision(repo, issue)
+    if card is None:
+        raise click.ClickException(f"no decision on file for {repo} #{issue}")
+
+    options = card.get("options") or []
+    if not options:
+        raise click.ClickException(f"decision card for {repo} #{issue} has no options")
+
+    if option_index is None:
+        index = next(
+            (i for i, opt in enumerate(options) if opt.get("recommended")), 0
+        )
+    else:
+        index = option_index
+        if not 0 <= index < len(options):
+            raise click.ClickException(
+                f"option index {index} out of range for {repo} #{issue} "
+                f"— valid indices are 0..{len(options) - 1}"
+            )
+
+    selected = options[index]
+    command = str(selected.get("command_or_action") or "").strip()
+    if not command:
+        raise click.ClickException(f"option {index} for {repo} #{issue} has no command")
+
+    click.echo(f"running: {command}")
+    result = subprocess.run(command, shell=True)  # noqa: S602 — operator-approved, one-key by design
+    if result.returncode != 0:
+        raise click.ClickException(f"chosen command exited {result.returncode}")
+
+    is_escalation_default = card.get("source") == "escalation" and bool(
+        selected.get("recommended")
+    )
+    if is_escalation_default:
+        if dismiss:
+            dismiss_drive_escalation(repo, issue)
+        click.echo("done")
+    else:
+        click.echo(
+            "done (no escalation record to dismiss — rerun "
+            "`coord report run decisions` to confirm this card is gone)"
+        )

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/coord/reports.py

@@ -79,6 +79,7 @@ __all__ = [
     "run_drive_queue_status",
     "fold_decisions",
     "run_decisions",
+    "find_decision",
     "resolve_usage_window",
     "fold_usage",
     "run_usage",
@@ -1602,6 +1603,48 @@ def run_decisions(
     return result
 
 
+def find_decision(
+    repo: str,
+    issue: int,
+    *,
+    now: float | None = None,
+    escalations_fetch: Callable[[str | None], Sequence[Mapping[str, Any]]] | None = None,
+    queue_fetch: Callable[[str | None], Sequence[Mapping[str, Any]]] | None = None,
+) -> dict[str, Any] | None:
+    """Look up the single `decisions` card for ``repo``#``issue``, fresh,
+    every call — `coord decide` (#2370) is required to never re-derive or
+    cache its own copy of "what the options are", so it calls this instead
+    of hand-rolling a filtered fold.
+
+    Folds the SAME full envelope :func:`run_decisions` would (escalation
+    table + the FULL, unfiltered drive queue — an `after=` chain can cross
+    repos, so scoping the queue fetch to ``repo`` before the cascade
+    collapse would misdiagnose a cross-repo prereq, same #2183 reasoning
+    `run_decisions` documents) but skips the title lookup entirely: unlike
+    the report, `coord decide` never displays a title, so paying for
+    `_lookup_titles` — which `run_decisions` already has to run for every
+    OTHER repo's cards too, since it only learns which cards are "this
+    repo's" after folding the whole fleet — would be pure waste for a
+    single-issue call.
+
+    Returns ``None`` if ``repo``#``issue`` has no open decision: no
+    escalation record and no blocked/failed queue row, OR it exists as a
+    queue row but folds as a `downstream` entry into some OTHER root's card
+    (matching the report itself, which gives that row no card of its own —
+    see `fold_decisions`'s cascade-collapse docstring).
+    """
+    generated_at = time.time() if now is None else float(now)
+    esc_fn = _default_list_drive_escalations if escalations_fetch is None else escalations_fetch
+    queue_fn = _default_list_drive_queue if queue_fetch is None else queue_fetch
+    escalations = list(esc_fn(None) or [])
+    queue_entries = list(queue_fn(None) or [])
+    result = fold_decisions(escalations, queue_entries, generated_at, titles=None)
+    for row in result.rows:
+        if row["repo"] == repo and int(row["issue"]) == int(issue):
+            return row
+    return None
+
+
 # ── usage: the per-issue / per-repo cost + token rollup ────────────────────
 #
 # #1763.  This is a **correctness fix**, not a consolidation.  `coord-tui`'s

code_coordinator-0.5.136/tests/test_cli_decide.py

@@ -0,0 +1,226 @@
+"""CLI-surface tests for `coord decide` (#2370).
+
+Generalizes `coord escalate run`'s one-key "run the proposed fix, dismiss on
+success" pattern to BOTH `decisions` report sources (#2369): a
+`drive_escalations` row (source-1) and a drive-queue `blocked`/`failed` row
+with no escalation record at all (source-2) — and to any option on the card,
+not just the recommended one.
+
+Same acceptance bar as `tests/test_cli_escalate.py`: drives the real Click
+CLI against a seeded local DB and asserts on its rendered output / DB state,
+never calls the fold functions directly.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from coord import state
+from coord.cli import main
+from coord.reports import run_decisions
+
+
+def _fake_run(seen: dict):
+    def run(command, shell=False, **kw):  # noqa: ANN001
+        seen["command"] = command
+        seen["shell"] = shell
+        return subprocess.CompletedProcess(command, 0)
+
+    return run
+
+
+def test_decide_is_registered_on_the_main_cli():
+    assert "decide" in main.commands
+
+
+def test_no_decision_on_file_is_a_clean_error(coord_db, valid_config_path: Path):
+    result = CliRunner().invoke(
+        main, ["decide", "api", "7", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code != 0
+    assert "no decision on file" in result.output
+    # a click.ClickException, never a raw traceback
+    assert "Traceback" not in result.output
+
+
+def test_no_index_on_escalation_card_behaves_exactly_like_escalate_run(
+    coord_db, valid_config_path: Path, monkeypatch
+):
+    state._record_drive_escalation_local(
+        "api", 7, stage="merge", reason="stuck", gate_readings="",
+        proposed_command="echo hi",
+    )
+    seen: dict = {}
+    monkeypatch.setattr("coord.commands.drive.subprocess.run", _fake_run(seen))
+
+    result = CliRunner().invoke(
+        main, ["decide", "api", "7", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+    assert seen["command"] == "echo hi"
+    assert seen["shell"] is True
+    # dismissed by default on success, exactly like `escalate run`
+    assert state._get_drive_escalation_local("api", 7) is None
+
+
+def test_index_0_is_the_same_as_omitting_the_index(
+    coord_db, valid_config_path: Path, monkeypatch
+):
+    state._record_drive_escalation_local(
+        "api", 7, stage="merge", reason="stuck", gate_readings="",
+        proposed_command="echo hi",
+    )
+    seen: dict = {}
+    monkeypatch.setattr("coord.commands.drive.subprocess.run", _fake_run(seen))
+
+    result = CliRunner().invoke(
+        main, ["decide", "api", "7", "0", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+    assert seen["command"] == "echo hi"
+    assert state._get_drive_escalation_local("api", 7) is None
+
+
+def test_non_default_option_on_an_escalation_card_never_dismisses(
+    coord_db, valid_config_path: Path, monkeypatch
+):
+    """Option 1 on a source-1 card ("Inspect") is NOT the record's
+    `proposed_command` — running it must leave the escalation record alone
+    and must not claim it dismissed anything."""
+    state._record_drive_escalation_local(
+        "api", 7, stage="merge", reason="stuck", gate_readings="",
+        proposed_command="echo hi",
+    )
+    seen: dict = {}
+    monkeypatch.setattr("coord.commands.drive.subprocess.run", _fake_run(seen))
+
+    result = CliRunner().invoke(
+        main, ["decide", "api", "7", "1", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+    assert seen["command"] == "coord escalate list --repo api"
+    assert "no escalation record to dismiss" in result.output
+    assert state._get_drive_escalation_local("api", 7) is not None
+
+
+def test_out_of_range_index_fails_cleanly_naming_the_valid_range(
+    coord_db, valid_config_path: Path
+):
+    state._record_drive_escalation_local(
+        "api", 7, stage="merge", reason="stuck", gate_readings="",
+        proposed_command="echo hi",
+    )
+    result = CliRunner().invoke(
+        main, ["decide", "api", "7", "5", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code != 0
+    assert "out of range" in result.output
+    assert "0..1" in result.output
+    # a clean click.ClickException, never a raw traceback
+    assert "Traceback" not in result.output
+
+
+def test_run_leaves_the_record_on_failure(coord_db, valid_config_path: Path, monkeypatch):
+    state._record_drive_escalation_local(
+        "api", 7, stage="merge", reason="stuck", gate_readings="",
+        proposed_command="false",
+    )
+    monkeypatch.setattr(
+        "coord.commands.drive.subprocess.run",
+        lambda command, shell=False, **kw: subprocess.CompletedProcess(command, 1),
+    )
+    result = CliRunner().invoke(
+        main, ["decide", "api", "7", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code != 0
+    assert state._get_drive_escalation_local("api", 7) is not None
+
+
+def test_no_dismiss_keeps_the_record_after_success(
+    coord_db, valid_config_path: Path, monkeypatch
+):
+    state._record_drive_escalation_local(
+        "api", 7, stage="merge", reason="stuck", gate_readings="",
+        proposed_command="echo hi",
+    )
+    monkeypatch.setattr(
+        "coord.commands.drive.subprocess.run",
+        lambda command, shell=False, **kw: subprocess.CompletedProcess(command, 0),
+    )
+    result = CliRunner().invoke(
+        main,
+        ["decide", "api", "7", "--no-dismiss", "--config", str(valid_config_path)],
+    )
+    assert result.exit_code == 0, result.output
+    assert state._get_drive_escalation_local("api", 7) is not None
+
+
+# ── source-2: drive-queue-only card, no escalation record at all (#2283) ────
+
+_TWO_OPTION_REASON = (
+    "acceptance author aid-1 failed.\n"
+    "   inspect: coord log aid-1 --machine dellserver\n"
+    "   remedy: echo remedy-command"
+)
+
+
+def _seed_blocked_queue_row(repo: str, issue: int, last_reason: str) -> None:
+    state.enqueue_drive_queue(repo, issue)
+    state._update_drive_queue_entry_local(
+        repo, issue, state="blocked", last_reason=last_reason
+    )
+
+
+def test_source2_card_default_index_runs_the_recommended_option(
+    coord_db, valid_config_path: Path, monkeypatch
+):
+    _seed_blocked_queue_row("api", 55, _TWO_OPTION_REASON)
+    seen: dict = {}
+    monkeypatch.setattr("coord.commands.drive.subprocess.run", _fake_run(seen))
+
+    result = CliRunner().invoke(
+        main, ["decide", "api", "55", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+    assert seen["command"] == "coord log aid-1 --machine dellserver"
+    assert "no escalation record to dismiss" in result.output
+    # never wrote a drive_escalations row for a source-2 card
+    assert state._get_drive_escalation_local("api", 55) is None
+
+
+def test_source2_card_explicit_index_runs_that_option_and_never_touches_escalations(
+    coord_db, valid_config_path: Path, monkeypatch
+):
+    _seed_blocked_queue_row("api", 55, _TWO_OPTION_REASON)
+    seen: dict = {}
+    monkeypatch.setattr("coord.commands.drive.subprocess.run", _fake_run(seen))
+
+    result = CliRunner().invoke(
+        main, ["decide", "api", "55", "1", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+    assert seen["command"] == "echo remedy-command"
+    assert state._get_drive_escalation_local("api", 55) is None
+
+
+def test_executed_command_is_byte_identical_to_the_decisions_report_option(
+    coord_db, valid_config_path: Path, monkeypatch
+):
+    """#2370 acceptance: `coord decide` must never paraphrase or re-derive
+    the command — it runs exactly what the `decisions` report's
+    `options[i].command_or_action` says for the same repo/issue/index."""
+    _seed_blocked_queue_row("api", 55, _TWO_OPTION_REASON)
+    seen: dict = {}
+    monkeypatch.setattr("coord.commands.drive.subprocess.run", _fake_run(seen))
+
+    result = CliRunner().invoke(
+        main, ["decide", "api", "55", "1", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+
+    report = run_decisions(repo="api")
+    card = next(r for r in report.rows if r["issue"] == 55)
+    assert seen["command"] == card["options"][1]["command_or_action"]

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/tests/test_reports.py

@@ -45,6 +45,7 @@ from coord.reports import (
     csv_filename,
     detect_prior_activity,
     fetch_audit_window,
+    find_decision,
     fold_decisions,
     fold_drive_queue_status,
     fold_issue_activity,
@@ -1304,6 +1305,90 @@ class TestRunDecisions:
         assert seen_keys == {("api", 1)}
 
 
+class TestFindDecision:
+    """`find_decision` (#2370) — the single-issue lookup `coord decide` calls
+    fresh every time instead of caching its own copy of "what the options
+    are". Same fold as `run_decisions`, minus the title lookup."""
+
+    def test_returns_none_when_nothing_is_pending(self) -> None:
+        assert find_decision(
+            "api", 7, now=1000.0,
+            escalations_fetch=lambda repo: [],
+            queue_fetch=lambda repo: [],
+        ) is None
+
+    def test_finds_the_escalation_card(self) -> None:
+        card = find_decision(
+            "api", 7, now=1000.0,
+            escalations_fetch=lambda repo: [_esc_row(7, repo="api", proposed_command="coord fix")],
+            queue_fetch=lambda repo: [],
+        )
+        assert card is not None
+        assert card["source"] == "escalation"
+        assert card["options"][0]["command_or_action"] == "coord fix"
+
+    def test_finds_the_queue_only_card(self) -> None:
+        rows = [
+            _dq_row(
+                55, repo="api", state_="blocked",
+                last_reason="something totally novel happened here",
+            )
+        ]
+        card = find_decision(
+            "api", 55, now=1000.0,
+            escalations_fetch=lambda repo: [],
+            queue_fetch=lambda repo: rows,
+        )
+        assert card is not None
+        assert card["source"] == "queue"
+
+    def test_returns_none_for_a_downstream_row_folded_into_another_card(self) -> None:
+        """A queue row that cascade-collapses into a root's `downstream` list
+        (#2283) gets no card of its own in the report — `find_decision` must
+        agree, not invent a standalone card the report would never show."""
+        rows = [
+            _dq_row(1, repo="api", state_="blocked", reason_at=100.0,
+                     last_reason=_ACCEPTANCE_DEAD_END_REASON),
+            _dq_row(
+                2, repo="api", state_="blocked", after_json=["api#1"],
+                last_reason=(
+                    "api#2's pre-req(s) (api#1) queued but blocked/failed "
+                    "— it will never satisfy"
+                ),
+            ),
+        ]
+        assert find_decision(
+            "api", 2, now=1000.0,
+            escalations_fetch=lambda repo: [],
+            queue_fetch=lambda repo: rows,
+        ) is None
+        # the root still resolves fine
+        root = find_decision(
+            "api", 1, now=1000.0,
+            escalations_fetch=lambda repo: [],
+            queue_fetch=lambda repo: rows,
+        )
+        assert root is not None
+        assert root["downstream"] == ["api#2"]
+
+    def test_queue_fetch_is_always_the_full_unfiltered_queue(self) -> None:
+        """Same #2183 reasoning `run_decisions` documents: an `after=` chain
+        can cross repos, so the queue fetch must never be scoped to `repo`
+        even though `find_decision` only wants one issue back."""
+        calls: list[str | None] = []
+
+        def queue_fetch(repo):
+            calls.append(repo)
+            return []
+
+        find_decision(
+            "api", 7, now=1000.0,
+            escalations_fetch=lambda repo: [],
+            queue_fetch=queue_fetch,
+        )
+        assert calls == [None]
+
+
 # ── registry + parameter validation ────────────────────────────────────────
 
 

{code_coordinator-0.5.135 → code_coordinator-0.5.136}/tui/src/app/dialogs.rs

@@ -858,9 +858,34 @@ impl CoordApp {
                     // isn't gated behind a confirmation dialog, so the
                     // operator should be able to read the whole command
                     // here before clicking — widen the budget accordingly.
-                    items.push(ContextMenuItem::action(
-                        "run-escalation",
+                    //
+                    // #2370: an escalation-table card always folds to TWO
+                    // `decisions`-report options (`coord/reports.py`'s
+                    // `fold_decisions`: "Recommended" = this row's
+                    // `proposed_command`, "Inspect" = `coord escalate list
+                    // --repo <repo>`) — so per the design's point 4 this is
+                    // always a pull-right submenu, never a flat action, and
+                    // each child calls `coord decide <repo> <issue>
+                    // <index>` (via `dispatch_decide_escalation`) instead of
+                    // `coord escalate run` directly. That command re-reads
+                    // the card fresh and runs `options[index]` itself —
+                    // this menu never re-derives or caches what the options
+                    // are, it only labels them for display.
+                    items.push(ContextMenuItem::parent(
                         &format!("Run proposed fix: {}", trunc(&esc.proposed_command, 56)),
+                        vec![
+                            ContextMenuItem::action(
+                                "decide-escalation:0",
+                                &format!(
+                                    "Recommended: {}",
+                                    trunc(&esc.proposed_command, 40)
+                                ),
+                            ),
+                            ContextMenuItem::action(
+                                "decide-escalation:1",
+                                "Inspect (view the full escalation record)",
+                            ),
+                        ],
                     ));
                     let has_pr = self
                         .pipeline_issues
@@ -6717,6 +6742,22 @@ impl CoordApp {
                 self.dispatch_dismiss_escalation(&repo, issue);
                 true
             }
+            // #2370: "Run proposed fix"'s submenu children — one per
+            // `decisions`-report option (`decide-escalation:0` =
+            // Recommended, `decide-escalation:1` = Inspect; see the
+            // `ContextMenuItem::parent` push above). The index rides in the
+            // action id (the `drive-queue-add-on:<machine>` precedent)
+            // since `ContextMenuItem` carries no per-item payload.
+            _ if action_id.starts_with("decide-escalation:") => {
+                let index: usize = action_id
+                    .strip_prefix("decide-escalation:")
+                    .and_then(|s| s.parse().ok())
+                    .unwrap_or(0);
+                if let Some((repo, issue)) = self.pipeline_menu_repo_issue(target) {
+                    self.dispatch_decide_escalation(&repo, issue, index);
+                }
+                true
+            }
             "start-with-plan" => {
                 let dispatched = self.dispatch_pipeline_plan();
                 if !dispatched {