rho-coding-agent 1.43.1

A lightweight agent harness inspired by Pi
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use pretty_assertions::assert_eq;

use super::super::{
    agent_picker::{InternalAgentModelPickerOrigin, InternalAgentModelTarget},
    tests::test_app,
    ComposerMode,
};
use crate::{agent::PERMISSION_CLASSIFIER_AGENT_ID, permission::PermissionMode};

fn startup_target() -> InternalAgentModelTarget {
    InternalAgentModelTarget {
        id: PERMISSION_CLASSIFIER_AGENT_ID.into(),
        origin: InternalAgentModelPickerOrigin::PermissionModeStartup,
    }
}

fn config_row_target() -> InternalAgentModelTarget {
    InternalAgentModelTarget {
        id: PERMISSION_CLASSIFIER_AGENT_ID.into(),
        origin: InternalAgentModelPickerOrigin::PermissionModeConfigRow,
    }
}

// Covers: Esc on the startup classifier picker must mark a demote so idle
// reconcile can apply Supervised without async agent handles on shared Esc.
// Owner: permission mode startup gate
#[test]
fn cancel_startup_classifier_prompt_marks_pending_demote() {
    let mut app = test_app();
    app.info.runtime.permission_mode = PermissionMode::Auto;
    app.internal_agent_model_target = Some(startup_target());

    assert!(app.cancel_permission_classifier_model_prompt(/*restore_input*/ true));

    assert!(app.pending_auto_classifier_demote);
    assert!(app.internal_agent_model_target.is_none());
    assert!(matches!(app.input_ui.composer(), ComposerMode::Input));
    assert_eq!(
        app.status(),
        "permission mode set to supervised: no classifier model selected"
    );
}

// Covers: canceling Auto enable from config must not demote the current mode.
// Owner: permission mode startup gate
#[test]
fn cancel_config_row_classifier_prompt_keeps_mode_without_demote() {
    let mut app = test_app();
    app.info.runtime.permission_mode = PermissionMode::Supervised;
    app.internal_agent_model_target = Some(config_row_target());

    assert!(app.cancel_permission_classifier_model_prompt(/*restore_input*/ true));

    assert!(!app.pending_auto_classifier_demote);
    assert_eq!(app.info.runtime.permission_mode, PermissionMode::Supervised);
    assert_eq!(
        app.status(),
        "permission mode stays supervised: no classifier model selected"
    );
}

// Covers: a failed model resolve (selected=false) must not schedule demote;
// only Esc cancel does. Otherwise Auto would flip to Supervised on a bad pick.
// Owner: permission mode startup gate
#[tokio::test]
async fn finish_startup_without_selection_does_not_mark_demote() {
    use crate::app::interactive_runtime::test_edit_tool_runtime;
    use crate::config::EditTool;

    let mut app = test_app();
    app.info.runtime.permission_mode = PermissionMode::Auto;
    app.pending_auto_classifier_demote = false;
    let mut agent = test_edit_tool_runtime(EditTool::Auto).await;

    app.finish_permission_classifier_model_selection(
        /*selected*/ false,
        InternalAgentModelPickerOrigin::PermissionModeStartup,
        &mut agent,
    )
    .await
    .unwrap();

    assert!(!app.pending_auto_classifier_demote);
    assert_eq!(app.info.runtime.permission_mode, PermissionMode::Auto);
}

// Covers: free composer + Auto without classifier must not stay silent —
// either open the startup picker or demote when no models exist.
// Owner: permission mode startup gate
#[tokio::test]
async fn reconcile_auto_without_classifier_opens_picker_or_demotes() {
    use crate::app::interactive_runtime::test_edit_tool_runtime;
    use crate::config::EditTool;

    let mut app = test_app();
    app.info.runtime.permission_mode = PermissionMode::Auto;
    app.info.runtime.internal_agents.clear();
    let mut agent = test_edit_tool_runtime(EditTool::Auto).await;
    agent
        .set_permission_mode(PermissionMode::Auto)
        .await
        .unwrap();

    app.reconcile_auto_classifier_gate(&mut agent)
        .await
        .unwrap();

    let opened_startup_picker = matches!(
        app.internal_agent_model_target.as_ref().map(|t| t.origin),
        Some(InternalAgentModelPickerOrigin::PermissionModeStartup)
    ) && matches!(app.input_ui.composer(), ComposerMode::Picker(_));
    let demoted = app.info.runtime.permission_mode == PermissionMode::Supervised
        && agent.permission_mode() == PermissionMode::Supervised;
    assert!(
        opened_startup_picker || demoted,
        "expected startup picker or Supervised fallback, got mode={:?}",
        app.info.runtime.permission_mode,
    );
}

// Covers: pending demote from startup Esc is applied on the next idle reconcile.
// Owner: permission mode startup gate
#[tokio::test]
async fn reconcile_applies_pending_startup_demote() {
    use crate::app::interactive_runtime::test_edit_tool_runtime;
    use crate::config::EditTool;

    let mut app = test_app();
    app.info.runtime.permission_mode = PermissionMode::Auto;
    app.info.runtime.internal_agents.clear();
    app.pending_auto_classifier_demote = true;
    let mut agent = test_edit_tool_runtime(EditTool::Auto).await;
    agent
        .set_permission_mode(PermissionMode::Auto)
        .await
        .unwrap();

    app.reconcile_auto_classifier_gate(&mut agent)
        .await
        .unwrap();

    assert!(!app.pending_auto_classifier_demote);
    assert_eq!(app.info.runtime.permission_mode, PermissionMode::Supervised);
    assert_eq!(agent.permission_mode(), PermissionMode::Supervised);
}