code-coordinator 0.5.146__tar.gz → 0.5.147__tar.gz

{code_coordinator-0.5.146 → code_coordinator-0.5.147}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.146
+Version: 0.5.147
 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.146 → code_coordinator-0.5.147}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.146
+Version: 0.5.147
 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.146 → code_coordinator-0.5.147}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.146",
+  "tag": "0.5.147",
   "distance": 0,
-  "node": "geabea71cd1e375065c4baa33f806f7f473662f82",
+  "node": "gbf9c09b2b36fbbb594b25c03bc8ef7844050cd84",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-18"

{code_coordinator-0.5.146 → code_coordinator-0.5.147}/coord/commands/drive.py

@@ -692,12 +692,22 @@ def escalate_run(repo: str, issue: int, dismiss: bool, config_path: Path) -> Non
         "option or a drive-queue-only card; see the command's docstring."
     ),
 )
+@click.option(
+    "--list", "list_only", is_flag=True, default=False,
+    help=(
+        "Print REPO ISSUE's numbered option list (same options "
+        "`coord report run decisions`/`coord escalate list` would show for "
+        "this row) and exit — runs nothing. #2375: the discovery path the "
+        "bare/indexed invocation deliberately doesn't provide."
+    ),
+)
 @_CONFIG_OPTION
 def decide(
     repo: str,
     issue: int,
     option_index: int | None,
     dismiss: bool,
+    list_only: bool,
     config_path: Path,
 ) -> None:
     """Run one option from REPO ISSUE's `decisions` report card.
@@ -724,8 +734,16 @@ def decide(
       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.
+
+    #2375: `--list` prints this same card's numbered options and stops —
+    the discovery path for picking OPTION_INDEX without running anything.
+    It is a NEW flag, not a change to the bare/no-index contract above:
+    that contract (#2370's own shipped acceptance criterion — no
+    OPTION_INDEX behaves identically to `coord escalate run`) stays exactly
+    as it is, since the TUI's "Recommended" click and #2370's acceptance
+    test both depend on it firing immediately.
     """
-    from coord.reports import find_decision  # noqa: PLC0415
+    from coord.reports import find_decision, format_option_cell  # noqa: PLC0415
     from coord.state import dismiss_drive_escalation  # noqa: PLC0415
 
     card = find_decision(repo, issue)
@@ -736,6 +754,12 @@ def decide(
     if not options:
         raise click.ClickException(f"decision card for {repo} #{issue} has no options")
 
+    if list_only:
+        click.echo(f"{repo} #{issue}: {len(options)} option(s)")
+        for i, opt in enumerate(options):
+            click.echo(f"  {i}: {format_option_cell(opt)}")
+        return
+
     if option_index is None:
         index = next(
             (i for i, opt in enumerate(options) if opt.get("recommended")), 0

{code_coordinator-0.5.146 → code_coordinator-0.5.147}/tests/test_cli_decide.py

@@ -206,6 +206,78 @@ def test_source2_card_explicit_index_runs_that_option_and_never_touches_escalati
     assert state._get_drive_escalation_local("api", 55) is None
 
 
+# ── --list: discovery path, executes nothing (#2375) ────────────────────────
+
+
+def test_list_prints_numbered_options_and_runs_nothing_for_escalation_card(
+    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", "--list", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+    assert "command" not in seen
+    assert "0:" in result.output and "Recommended: echo hi" in result.output
+    assert "1:" in result.output and "Inspect: coord escalate list --repo api" in result.output
+    # nothing dismissed either — --list never touches state
+    assert state._get_drive_escalation_local("api", 7) is not None
+
+
+def test_list_prints_numbered_options_for_source2_card(
+    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", "--list", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+    assert "command" not in seen
+    assert "coord log aid-1 --machine dellserver" in result.output
+    assert "echo remedy-command" in result.output
+
+
+def test_list_matches_the_decisions_report_options_exactly(
+    coord_db, valid_config_path: Path
+):
+    """#2375 acceptance: `--list`'s numbered options are the same ones
+    `coord report run decisions` (and thus `format_option_cell`) would show
+    for this same card, byte-for-byte."""
+    _seed_blocked_queue_row("api", 55, _TWO_OPTION_REASON)
+
+    result = CliRunner().invoke(
+        main, ["decide", "api", "55", "--list", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code == 0, result.output
+
+    from coord.reports import format_option_cell
+
+    report = run_decisions(repo="api")
+    card = next(r for r in report.rows if r["issue"] == 55)
+    for i, opt in enumerate(card["options"]):
+        assert f"  {i}: {format_option_cell(opt)}" in result.output
+
+
+def test_list_with_no_decision_on_file_is_a_clean_error(
+    coord_db, valid_config_path: Path
+):
+    result = CliRunner().invoke(
+        main, ["decide", "api", "7", "--list", "--config", str(valid_config_path)]
+    )
+    assert result.exit_code != 0
+    assert "no decision on file" in result.output
+    assert "Traceback" not in result.output
+
+
 def test_executed_command_is_byte_identical_to_the_decisions_report_option(
     coord_db, valid_config_path: Path, monkeypatch
 ):

{code_coordinator-0.5.146 → code_coordinator-0.5.147}/tui/src/app/dialogs.rs

@@ -871,22 +871,13 @@ impl CoordApp {
                     // 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)",
-                            ),
-                        ],
-                    ));
+                    //
+                    // #2375: the construction itself now lives in
+                    // `escalation.rs`'s `run_proposed_fix_menu_item`, shared
+                    // with the drive-queue Queue-panel row menu, so the two
+                    // panels can never render different children/ordering
+                    // for the same (repo, issue).
+                    items.push(Self::run_proposed_fix_menu_item(esc));
                     let has_pr = self
                         .pipeline_issues
                         .iter()

{code_coordinator-0.5.146 → code_coordinator-0.5.147}/tui/src/app/drive_queue.rs

@@ -435,6 +435,18 @@ impl CoordApp {
                 repo_name,
                 ..
             } => Some((repo_name.clone()?, (*issue_number)?)),
+            // #2375: the Queue panel's own row now offers the same
+            // `decide-escalation:<index>` submenu the Pipeline row does
+            // (`context_menu_items_for_drive_queue_row`), so its dispatch
+            // needs the same repo/issue resolution — `issue_number` here is
+            // a non-optional `i64` (a queue row always names one), matching
+            // the `.max(0) as u64` clamp `context_menu_items_for_drive_queue_row`
+            // already uses to build the escalation lookup.
+            ContextMenuTarget::DriveQueueRow {
+                repo_name,
+                issue_number,
+                ..
+            } => Some((repo_name.clone(), (*issue_number).max(0) as u64)),
             _ => None,
         }
     }
@@ -520,10 +532,26 @@ impl CoordApp {
         held: bool,
     ) -> Vec<ContextMenuItem> {
         let mut items = Vec::new();
-        // #1757: FIRST, and only on a row that is actually holding the
-        // queue. When a gate has fired this is the only action that changes
-        // anything — everything below it just rearranges work that cannot
-        // start — so it must not be buried under three moves.
+        // #2375: the SAME "Run proposed fix" submenu the Pipeline row menu
+        // offers for an open escalation (`dialogs.rs`'s `escalation_for`
+        // branch) — the queue panel is arguably the more natural place to
+        // decide a stuck row from, so reaching this action must not require
+        // a context-switch to Pipeline to find the same row. Built through
+        // the shared `escalation.rs` helper so the two panels can never
+        // drift into rendering different children/ordering for one
+        // (repo, issue). A row with no open escalation is unaffected — the
+        // lookup returns `None` and this block is skipped entirely.
+        if let Some(esc) = self.escalation_for(repo_name, issue_number.max(0) as u64) {
+            items.push(Self::run_proposed_fix_menu_item(esc));
+            items.push(ContextMenuItem::separator());
+        }
+        // #1757: first among the state-changing actions below (the escalation
+        // block above, when present, still leads the whole menu — a driver
+        // stuck on merge is a bigger deal than a deploy gate), and only on a
+        // row that is actually holding the queue. When a gate has fired this
+        // is the only action that changes anything — everything below it
+        // just rearranges work that cannot start — so it must not be buried
+        // under three moves.
         if held {
             items.push(
                 ContextMenuItem::action("drive-queue-resume", "Resume (release deploy gate)")
@@ -2366,6 +2394,167 @@ mod tests {
         assert!(last.iter().any(|i| i.label == "Unblock"));
     }
 
+    // ── "Run proposed fix" submenu on an escalated row (#2375) ───────────
+
+    fn escalation(repo: &str, issue_number: u64) -> EscalationEntry {
+        EscalationEntry {
+            id: 1,
+            repo_name: repo.to_string(),
+            issue_number: issue_number as i64,
+            stage: "merge".to_string(),
+            assignment_id: Some("w1".to_string()),
+            reason: "merge_status=NEEDS_ATTENTION — no number of retries changes this".to_string(),
+            gate_readings:
+                "merge_status=NEEDS_ATTENTION | pr_url=https://github.com/acme/myrepo/pull/9"
+                    .to_string(),
+            proposed_command: "gh pr merge 9 --rebase && coord reconcile-merges".to_string(),
+            created_at: Some(1.0),
+        }
+    }
+
+    #[test]
+    fn queue_row_menu_unchanged_when_no_escalation_is_open() {
+        let app = make_test_app(BoardData::default());
+        let items = app.context_menu_items_for_drive_queue_row(
+            "myrepo",
+            42,
+            QUEUE_STATE_WAITING,
+            0,
+            3,
+            false,
+        );
+        assert!(
+            !items
+                .iter()
+                .any(|i| i.label.starts_with("Run proposed fix")),
+            "a row with no open escalation must render exactly as before #2375: {items:?}"
+        );
+        assert_eq!(
+            items[0].action_id.as_deref(),
+            Some("drive-queue-move-up"),
+            "no escalation block inserted ahead of the moves"
+        );
+    }
+
+    #[test]
+    fn queue_row_menu_offers_run_proposed_fix_when_escalated() {
+        let app = make_test_app(BoardData {
+            escalations: vec![escalation("myrepo", 42)],
+            ..BoardData::default()
+        });
+        let items = app.context_menu_items_for_drive_queue_row(
+            "myrepo",
+            42,
+            QUEUE_STATE_WAITING,
+            0,
+            3,
+            false,
+        );
+        let parent = items
+            .iter()
+            .find(|i| i.label.starts_with("Run proposed fix"))
+            .expect("'Run proposed fix' item not found in escalated queue row's menu");
+        let children = parent
+            .submenu
+            .as_ref()
+            .expect("'Run proposed fix' must be a pull-right submenu, not a flat action");
+        assert_eq!(
+            children
+                .iter()
+                .map(|c| c.action_id.as_deref())
+                .collect::<Vec<_>>(),
+            vec![Some("decide-escalation:0"), Some("decide-escalation:1")],
+            "each submenu entry must call `coord decide` with its own option index"
+        );
+    }
+
+    #[test]
+    fn queue_row_menu_matches_pipeline_row_menu_for_the_same_escalation() {
+        // #2375 acceptance: seeding one escalation + one drive-queue row for
+        // the same (repo, issue) must produce the SAME "Run proposed fix"
+        // submenu — same recommended command, same child ordering — from
+        // both `context_menu_items_for_drive_queue_row` (this module) and
+        // `context_menu_items_for_pipeline_row` (`dialogs.rs`).
+        let mut app = make_test_app(BoardData {
+            escalations: vec![escalation("myrepo", 42)],
+            drive_queue: vec![entry(42, 0, QUEUE_STATE_WAITING, &[])],
+            ..BoardData::default()
+        });
+        app.pipeline_issues = vec![pipeline_issue(42, Some("myrepo"))];
+
+        let queue_items = app.context_menu_items_for_drive_queue_row(
+            "myrepo",
+            42,
+            QUEUE_STATE_WAITING,
+            0,
+            1,
+            false,
+        );
+        let pipeline_items = app.context_menu_items_for_pipeline_row(
+            Some(42),
+            &crate::app::types::PipelineRowLifecycle::New,
+            Some("myrepo"),
+        );
+
+        let queue_parent = queue_items
+            .iter()
+            .find(|i| i.label.starts_with("Run proposed fix"))
+            .expect("queue row menu missing 'Run proposed fix'");
+        let pipeline_parent = pipeline_items
+            .iter()
+            .find(|i| i.label.starts_with("Run proposed fix"))
+            .expect("pipeline row menu missing 'Run proposed fix'");
+
+        assert_eq!(
+            queue_parent.label, pipeline_parent.label,
+            "both panels must name the same recommended command"
+        );
+        let queue_children = queue_parent.submenu.as_ref().expect("queue submenu");
+        let pipeline_children = pipeline_parent.submenu.as_ref().expect("pipeline submenu");
+        assert_eq!(
+            queue_children
+                .iter()
+                .map(|c| (c.action_id.clone(), c.label.clone()))
+                .collect::<Vec<_>>(),
+            pipeline_children
+                .iter()
+                .map(|c| (c.action_id.clone(), c.label.clone()))
+                .collect::<Vec<_>>(),
+            "same action ids, same labels, same order on both panels"
+        );
+    }
+
+    #[test]
+    fn queue_row_decide_escalation_dispatch_resolves_repo_and_issue() {
+        // `pipeline_menu_repo_issue` now also resolves a `DriveQueueRow`
+        // target (#2375) — without this, the submenu's
+        // `decide-escalation:<index>` action id would silently no-op when
+        // clicked from the Queue panel.
+        let mut app = make_test_app(BoardData {
+            escalations: vec![escalation("myrepo", 42)],
+            ..BoardData::default()
+        });
+        let target = crate::app::types::ContextMenuTarget::DriveQueueRow {
+            repo_name: "myrepo".to_string(),
+            issue_number: 42,
+            state: QUEUE_STATE_WAITING.to_string(),
+            position: 0,
+            queue_len: 1,
+            held: false,
+        };
+        app.dispatch_context_menu_action("decide-escalation:0", &target);
+        assert_eq!(
+            app.command_runner.spawned_calls,
+            vec![vec![
+                "decide".to_string(),
+                "myrepo".to_string(),
+                "42".to_string(),
+                "0".to_string(),
+            ]],
+            "clicking the queue-panel submenu must dispatch `coord decide myrepo 42 0`"
+        );
+    }
+
     // ── dispatch: the `coord drive-queue …` argv ─────────────────────────
 
     #[test]

{code_coordinator-0.5.146 → code_coordinator-0.5.147}/tui/src/app/escalation.rs

@@ -241,6 +241,38 @@ impl CoordApp {
         }
     }
 
+    /// The "Run proposed fix: `<cmd>`" pull-right submenu for an open
+    /// escalation record — 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 this is always a submenu, never a
+    /// flat action, and each child calls `coord decide <repo> <issue>
+    /// <index>` (via `dispatch_decide_escalation`, dispatched through the
+    /// `decide-escalation:<index>` action-id convention) instead of `coord
+    /// escalate run` directly.
+    ///
+    /// #2375: pulled out of `dialogs.rs`'s Pipeline-row menu builder so the
+    /// drive-queue Queue-panel row menu (`drive_queue.rs`) can offer the
+    /// IDENTICAL submenu for the same (repo, issue) — same recommended
+    /// command, same child ordering — without a second hand-rolled copy of
+    /// this `ContextMenuItem::parent(...)` construction to drift out of
+    /// sync with the original.
+    pub(crate) fn run_proposed_fix_menu_item(esc: &EscalationEntry) -> ContextMenuItem {
+        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)",
+                ),
+            ],
+        )
+    }
+
     /// "Decide" — generalizes `dispatch_run_escalation` to any option on
     /// the card's `decisions`-report shape, not just the recommended one
     /// (#2370). Shells out to `coord decide <repo> <issue> <option_index>`,