538 lines
17 KiB
Rust
538 lines
17 KiB
Rust
|
//! Assign command: pre-assign or re-assign a coder model to a story.
|
||
|
|
//!
|
||
|
|
//! `{bot_name} assign {number} {model}` finds the story by number, updates the
|
||
|
|
//! `agent` field in its front matter, and — when a coder is already running on
|
||
|
|
//! the story — stops the current coder and starts the newly-assigned one.
|
||
|
|
//!
|
||
|
|
//! When no coder is running (the story has not been started yet), the command
|
||
|
|
//! behaves as before: it simply persists the assignment in the front matter so
|
||
|
|
//! that the next `start` invocation picks it up automatically.
|
||
|
|
|
||
|
|
use crate::agents::{AgentPool, AgentStatus};
|
||
|
|
use crate::io::story_metadata::{parse_front_matter, set_front_matter_field};
|
||
|
|
use std::path::Path;
|
||
|
|
|
||
|
|
/// All pipeline stage directories to search when finding a work item by number.
|
||
|
|
const STAGES: &[&str] = &[
|
||
|
|
"1_backlog",
|
||
|
|
"2_current",
|
||
|
|
"3_qa",
|
||
|
|
"4_merge",
|
||
|
|
"5_done",
|
||
|
|
"6_archived",
|
||
|
|
];
|
||
|
|
|
||
|
|
/// A parsed assign command from a Matrix message body.
|
||
|
|
#[derive(Debug, PartialEq)]
|
||
|
|
pub enum AssignCommand {
|
||
|
|
/// Assign the story with this number to the given model.
|
||
|
|
Assign {
|
||
|
|
story_number: String,
|
||
|
|
model: String,
|
||
|
|
},
|
||
|
|
/// The user typed `assign` but without valid arguments.
|
||
|
|
BadArgs,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Parse an assign command from a raw Matrix message body.
|
||
|
|
///
|
||
|
|
/// Strips the bot mention prefix and checks whether the first word is `assign`.
|
||
|
|
/// Returns `None` when the message is not an assign command at all.
|
||
|
|
pub fn extract_assign_command(
|
||
|
|
message: &str,
|
||
|
|
bot_name: &str,
|
||
|
|
bot_user_id: &str,
|
||
|
|
) -> Option<AssignCommand> {
|
||
|
|
let stripped = strip_mention(message, bot_name, bot_user_id);
|
||
|
|
let trimmed = stripped
|
||
|
|
.trim()
|
||
|
|
.trim_start_matches(|c: char| !c.is_alphanumeric());
|
||
|
|
|
||
|
|
let (cmd, args) = match trimmed.split_once(char::is_whitespace) {
|
||
|
|
Some((c, a)) => (c, a.trim()),
|
||
|
|
None => (trimmed, ""),
|
||
|
|
};
|
||
|
|
|
||
|
|
if !cmd.eq_ignore_ascii_case("assign") {
|
||
|
|
return None;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Split args into story number and model.
|
||
|
|
let (number_str, model_str) = match args.split_once(char::is_whitespace) {
|
||
|
|
Some((n, m)) => (n.trim(), m.trim()),
|
||
|
|
None => (args, ""),
|
||
|
|
};
|
||
|
|
|
||
|
|
if number_str.is_empty()
|
||
|
|
|| !number_str.chars().all(|c| c.is_ascii_digit())
|
||
|
|
|| model_str.is_empty()
|
||
|
|
{
|
||
|
|
return Some(AssignCommand::BadArgs);
|
||
|
|
}
|
||
|
|
|
||
|
|
Some(AssignCommand::Assign {
|
||
|
|
story_number: number_str.to_string(),
|
||
|
|
model: model_str.to_string(),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Resolve a model name hint (e.g. `"opus"`) to a full agent name
|
||
|
|
/// (e.g. `"coder-opus"`). If the hint already starts with `"coder-"`,
|
||
|
|
/// it is returned unchanged to prevent double-prefixing.
|
||
|
|
pub fn resolve_agent_name(model: &str) -> String {
|
||
|
|
if model.starts_with("coder-") {
|
||
|
|
model.to_string()
|
||
|
|
} else {
|
||
|
|
format!("coder-{model}")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Handle an assign command asynchronously.
|
||
|
|
///
|
||
|
|
/// Finds the work item by `story_number` across all pipeline stages, updates
|
||
|
|
/// the `agent` field in its front matter, and — if a coder is currently
|
||
|
|
/// running on the story — stops it and starts the newly-assigned agent.
|
||
|
|
/// Returns a markdown-formatted response string.
|
||
|
|
pub async fn handle_assign(
|
||
|
|
bot_name: &str,
|
||
|
|
story_number: &str,
|
||
|
|
model_str: &str,
|
||
|
|
project_root: &Path,
|
||
|
|
agents: &AgentPool,
|
||
|
|
) -> String {
|
||
|
|
// Find the story file across all pipeline stages.
|
||
|
|
let mut found: Option<(std::path::PathBuf, String)> = None;
|
||
|
|
'outer: for stage in STAGES {
|
||
|
|
let dir = project_root.join(".storkit").join("work").join(stage);
|
||
|
|
if !dir.exists() {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if let Ok(entries) = std::fs::read_dir(&dir) {
|
||
|
|
for entry in entries.flatten() {
|
||
|
|
let path = entry.path();
|
||
|
|
if path.extension().and_then(|e| e.to_str()) != Some("md") {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if let Some(stem) = path
|
||
|
|
.file_stem()
|
||
|
|
.and_then(|s| s.to_str())
|
||
|
|
.map(|s| s.to_string())
|
||
|
|
{
|
||
|
|
let file_num = stem
|
||
|
|
.split('_')
|
||
|
|
.next()
|
||
|
|
.filter(|s| !s.is_empty() && s.chars().all(|c| c.is_ascii_digit()))
|
||
|
|
.unwrap_or("")
|
||
|
|
.to_string();
|
||
|
|
if file_num == story_number {
|
||
|
|
found = Some((path, stem));
|
||
|
|
break 'outer;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let (path, story_id) = match found {
|
||
|
|
Some(f) => f,
|
||
|
|
None => {
|
||
|
|
return format!(
|
||
|
|
"No story, bug, or spike with number **{story_number}** found."
|
||
|
|
);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
// Read the human-readable name from front matter for the response.
|
||
|
|
let story_name = std::fs::read_to_string(&path)
|
||
|
|
.ok()
|
||
|
|
.and_then(|contents| {
|
||
|
|
parse_front_matter(&contents)
|
||
|
|
.ok()
|
||
|
|
.and_then(|m| m.name)
|
||
|
|
})
|
||
|
|
.unwrap_or_else(|| story_id.clone());
|
||
|
|
|
||
|
|
let agent_name = resolve_agent_name(model_str);
|
||
|
|
|
||
|
|
// Write `agent: <agent_name>` into the story's front matter.
|
||
|
|
let write_result = std::fs::read_to_string(&path)
|
||
|
|
.map_err(|e| format!("Failed to read story file: {e}"))
|
||
|
|
.and_then(|contents| {
|
||
|
|
let updated = set_front_matter_field(&contents, "agent", &agent_name);
|
||
|
|
std::fs::write(&path, &updated)
|
||
|
|
.map_err(|e| format!("Failed to write story file: {e}"))
|
||
|
|
});
|
||
|
|
|
||
|
|
if let Err(e) = write_result {
|
||
|
|
return format!("Failed to assign model to **{story_name}**: {e}");
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check whether a coder is already running on this story.
|
||
|
|
let running_coders: Vec<_> = agents
|
||
|
|
.list_agents()
|
||
|
|
.unwrap_or_default()
|
||
|
|
.into_iter()
|
||
|
|
.filter(|a| {
|
||
|
|
a.story_id == story_id
|
||
|
|
&& a.agent_name.starts_with("coder")
|
||
|
|
&& matches!(a.status, AgentStatus::Running | AgentStatus::Pending)
|
||
|
|
})
|
||
|
|
.collect();
|
||
|
|
|
||
|
|
if running_coders.is_empty() {
|
||
|
|
// No coder running — just persist the assignment.
|
||
|
|
return format!(
|
||
|
|
"Assigned **{agent_name}** to **{story_name}** (story {story_number}). \
|
||
|
|
The model will be used when the story starts."
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Stop each running coder, then start the newly assigned one.
|
||
|
|
let stopped: Vec<String> = running_coders
|
||
|
|
.iter()
|
||
|
|
.map(|a| a.agent_name.clone())
|
||
|
|
.collect();
|
||
|
|
|
||
|
|
for coder in &running_coders {
|
||
|
|
if let Err(e) = agents
|
||
|
|
.stop_agent(project_root, &story_id, &coder.agent_name)
|
||
|
|
.await
|
||
|
|
{
|
||
|
|
crate::slog!(
|
||
|
|
"[matrix-bot] assign: failed to stop agent {} for {}: {e}",
|
||
|
|
coder.agent_name,
|
||
|
|
story_id
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
crate::slog!(
|
||
|
|
"[matrix-bot] assign (bot={bot_name}): stopped {:?} for {}; starting {agent_name}",
|
||
|
|
stopped,
|
||
|
|
story_id
|
||
|
|
);
|
||
|
|
|
||
|
|
match agents
|
||
|
|
.start_agent(project_root, &story_id, Some(&agent_name), None)
|
||
|
|
.await
|
||
|
|
{
|
||
|
|
Ok(info) => {
|
||
|
|
format!(
|
||
|
|
"Reassigned **{story_name}** (story {story_number}): \
|
||
|
|
stopped **{}** and started **{}**.",
|
||
|
|
stopped.join(", "),
|
||
|
|
info.agent_name
|
||
|
|
)
|
||
|
|
}
|
||
|
|
Err(e) => {
|
||
|
|
format!(
|
||
|
|
"Assigned **{agent_name}** to **{story_name}** (story {story_number}): \
|
||
|
|
stopped **{}** but failed to start the new agent: {e}",
|
||
|
|
stopped.join(", ")
|
||
|
|
)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Strip the bot mention prefix from a raw Matrix message body.
|
||
|
|
///
|
||
|
|
/// Mirrors the logic in `commands::strip_bot_mention` and `start::strip_mention`.
|
||
|
|
fn strip_mention<'a>(message: &'a str, bot_name: &str, bot_user_id: &str) -> &'a str {
|
||
|
|
let trimmed = message.trim();
|
||
|
|
if let Some(rest) = strip_prefix_ci(trimmed, bot_user_id) {
|
||
|
|
return rest;
|
||
|
|
}
|
||
|
|
if let Some(localpart) = bot_user_id.split(':').next()
|
||
|
|
&& let Some(rest) = strip_prefix_ci(trimmed, localpart)
|
||
|
|
{
|
||
|
|
return rest;
|
||
|
|
}
|
||
|
|
if let Some(rest) = strip_prefix_ci(trimmed, bot_name) {
|
||
|
|
return rest;
|
||
|
|
}
|
||
|
|
trimmed
|
||
|
|
}
|
||
|
|
|
||
|
|
fn strip_prefix_ci<'a>(text: &'a str, prefix: &str) -> Option<&'a str> {
|
||
|
|
if text.len() < prefix.len() {
|
||
|
|
return None;
|
||
|
|
}
|
||
|
|
if !text[..prefix.len()].eq_ignore_ascii_case(prefix) {
|
||
|
|
return None;
|
||
|
|
}
|
||
|
|
let rest = &text[prefix.len()..];
|
||
|
|
match rest.chars().next() {
|
||
|
|
None => Some(rest),
|
||
|
|
Some(c) if c.is_alphanumeric() || c == '-' || c == '_' => None,
|
||
|
|
_ => Some(rest),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------------------------------------------------------------------------
|
||
|
|
// Tests
|
||
|
|
// ---------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests {
|
||
|
|
use super::*;
|
||
|
|
|
||
|
|
// -- extract_assign_command -----------------------------------------------
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_with_full_user_id() {
|
||
|
|
let cmd = extract_assign_command(
|
||
|
|
"@timmy:home.local assign 42 opus",
|
||
|
|
"Timmy",
|
||
|
|
"@timmy:home.local",
|
||
|
|
);
|
||
|
|
assert_eq!(
|
||
|
|
cmd,
|
||
|
|
Some(AssignCommand::Assign {
|
||
|
|
story_number: "42".to_string(),
|
||
|
|
model: "opus".to_string()
|
||
|
|
})
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_with_display_name() {
|
||
|
|
let cmd = extract_assign_command("Timmy assign 42 sonnet", "Timmy", "@timmy:home.local");
|
||
|
|
assert_eq!(
|
||
|
|
cmd,
|
||
|
|
Some(AssignCommand::Assign {
|
||
|
|
story_number: "42".to_string(),
|
||
|
|
model: "sonnet".to_string()
|
||
|
|
})
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_with_localpart() {
|
||
|
|
let cmd = extract_assign_command("@timmy assign 7 opus", "Timmy", "@timmy:home.local");
|
||
|
|
assert_eq!(
|
||
|
|
cmd,
|
||
|
|
Some(AssignCommand::Assign {
|
||
|
|
story_number: "7".to_string(),
|
||
|
|
model: "opus".to_string()
|
||
|
|
})
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_case_insensitive_command() {
|
||
|
|
let cmd = extract_assign_command("Timmy ASSIGN 99 opus", "Timmy", "@timmy:home.local");
|
||
|
|
assert_eq!(
|
||
|
|
cmd,
|
||
|
|
Some(AssignCommand::Assign {
|
||
|
|
story_number: "99".to_string(),
|
||
|
|
model: "opus".to_string()
|
||
|
|
})
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_no_args_is_bad_args() {
|
||
|
|
let cmd = extract_assign_command("Timmy assign", "Timmy", "@timmy:home.local");
|
||
|
|
assert_eq!(cmd, Some(AssignCommand::BadArgs));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_missing_model_is_bad_args() {
|
||
|
|
let cmd = extract_assign_command("Timmy assign 42", "Timmy", "@timmy:home.local");
|
||
|
|
assert_eq!(cmd, Some(AssignCommand::BadArgs));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_non_numeric_number_is_bad_args() {
|
||
|
|
let cmd = extract_assign_command("Timmy assign abc opus", "Timmy", "@timmy:home.local");
|
||
|
|
assert_eq!(cmd, Some(AssignCommand::BadArgs));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn extract_non_assign_command_returns_none() {
|
||
|
|
let cmd = extract_assign_command("Timmy help", "Timmy", "@timmy:home.local");
|
||
|
|
assert_eq!(cmd, None);
|
||
|
|
}
|
||
|
|
|
||
|
|
// -- resolve_agent_name --------------------------------------------------
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn resolve_agent_name_prefixes_bare_model() {
|
||
|
|
assert_eq!(resolve_agent_name("opus"), "coder-opus");
|
||
|
|
assert_eq!(resolve_agent_name("sonnet"), "coder-sonnet");
|
||
|
|
assert_eq!(resolve_agent_name("haiku"), "coder-haiku");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn resolve_agent_name_does_not_double_prefix() {
|
||
|
|
assert_eq!(resolve_agent_name("coder-opus"), "coder-opus");
|
||
|
|
assert_eq!(resolve_agent_name("coder-sonnet"), "coder-sonnet");
|
||
|
|
}
|
||
|
|
|
||
|
|
// -- handle_assign (no running coder) ------------------------------------
|
||
|
|
|
||
|
|
fn write_story_file(root: &Path, stage: &str, filename: &str, content: &str) {
|
||
|
|
let dir = root.join(".storkit/work").join(stage);
|
||
|
|
std::fs::create_dir_all(&dir).unwrap();
|
||
|
|
std::fs::write(dir.join(filename), content).unwrap();
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn handle_assign_returns_not_found_for_unknown_number() {
|
||
|
|
let tmp = tempfile::tempdir().unwrap();
|
||
|
|
for stage in STAGES {
|
||
|
|
std::fs::create_dir_all(tmp.path().join(".storkit/work").join(stage)).unwrap();
|
||
|
|
}
|
||
|
|
let agents = std::sync::Arc::new(AgentPool::new_test(3000));
|
||
|
|
let response = handle_assign("Timmy", "999", "opus", tmp.path(), &agents).await;
|
||
|
|
assert!(
|
||
|
|
response.contains("No story") && response.contains("999"),
|
||
|
|
"unexpected response: {response}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn handle_assign_writes_front_matter_when_no_coder_running() {
|
||
|
|
let tmp = tempfile::tempdir().unwrap();
|
||
|
|
write_story_file(
|
||
|
|
tmp.path(),
|
||
|
|
"1_backlog",
|
||
|
|
"42_story_test.md",
|
||
|
|
"---\nname: Test Feature\n---\n\n# Story 42\n",
|
||
|
|
);
|
||
|
|
|
||
|
|
let agents = std::sync::Arc::new(AgentPool::new_test(3000));
|
||
|
|
let response = handle_assign("Timmy", "42", "opus", tmp.path(), &agents).await;
|
||
|
|
|
||
|
|
assert!(
|
||
|
|
response.contains("coder-opus"),
|
||
|
|
"response should mention agent: {response}"
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
response.contains("Test Feature"),
|
||
|
|
"response should mention story name: {response}"
|
||
|
|
);
|
||
|
|
// Should say "will be used when the story starts" (no restart)
|
||
|
|
assert!(
|
||
|
|
response.contains("start"),
|
||
|
|
"response should indicate assignment for future start: {response}"
|
||
|
|
);
|
||
|
|
|
||
|
|
let contents = std::fs::read_to_string(
|
||
|
|
tmp.path().join(".storkit/work/1_backlog/42_story_test.md"),
|
||
|
|
)
|
||
|
|
.unwrap();
|
||
|
|
assert!(
|
||
|
|
contents.contains("agent: coder-opus"),
|
||
|
|
"front matter should contain agent field: {contents}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn handle_assign_with_already_prefixed_name_does_not_double_prefix() {
|
||
|
|
let tmp = tempfile::tempdir().unwrap();
|
||
|
|
write_story_file(
|
||
|
|
tmp.path(),
|
||
|
|
"1_backlog",
|
||
|
|
"7_story_small.md",
|
||
|
|
"---\nname: Small Story\n---\n",
|
||
|
|
);
|
||
|
|
|
||
|
|
let agents = std::sync::Arc::new(AgentPool::new_test(3000));
|
||
|
|
let response = handle_assign("Timmy", "7", "coder-opus", tmp.path(), &agents).await;
|
||
|
|
|
||
|
|
assert!(
|
||
|
|
response.contains("coder-opus"),
|
||
|
|
"should not double-prefix: {response}"
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
!response.contains("coder-coder-opus"),
|
||
|
|
"must not double-prefix: {response}"
|
||
|
|
);
|
||
|
|
|
||
|
|
let contents = std::fs::read_to_string(
|
||
|
|
tmp.path().join(".storkit/work/1_backlog/7_story_small.md"),
|
||
|
|
)
|
||
|
|
.unwrap();
|
||
|
|
assert!(
|
||
|
|
contents.contains("agent: coder-opus"),
|
||
|
|
"must write coder-opus, not coder-coder-opus: {contents}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn handle_assign_overwrites_existing_agent_field() {
|
||
|
|
let tmp = tempfile::tempdir().unwrap();
|
||
|
|
write_story_file(
|
||
|
|
tmp.path(),
|
||
|
|
"1_backlog",
|
||
|
|
"5_story_existing.md",
|
||
|
|
"---\nname: Existing\nagent: coder-sonnet\n---\n",
|
||
|
|
);
|
||
|
|
|
||
|
|
let agents = std::sync::Arc::new(AgentPool::new_test(3000));
|
||
|
|
handle_assign("Timmy", "5", "opus", tmp.path(), &agents).await;
|
||
|
|
|
||
|
|
let contents = std::fs::read_to_string(
|
||
|
|
tmp.path().join(".storkit/work/1_backlog/5_story_existing.md"),
|
||
|
|
)
|
||
|
|
.unwrap();
|
||
|
|
assert!(
|
||
|
|
contents.contains("agent: coder-opus"),
|
||
|
|
"should overwrite old agent: {contents}"
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
!contents.contains("coder-sonnet"),
|
||
|
|
"old agent should no longer appear: {contents}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn handle_assign_finds_story_in_any_stage() {
|
||
|
|
let tmp = tempfile::tempdir().unwrap();
|
||
|
|
write_story_file(
|
||
|
|
tmp.path(),
|
||
|
|
"3_qa",
|
||
|
|
"99_story_in_qa.md",
|
||
|
|
"---\nname: In QA\n---\n",
|
||
|
|
);
|
||
|
|
|
||
|
|
let agents = std::sync::Arc::new(AgentPool::new_test(3000));
|
||
|
|
let response = handle_assign("Timmy", "99", "opus", tmp.path(), &agents).await;
|
||
|
|
assert!(
|
||
|
|
response.contains("coder-opus"),
|
||
|
|
"should find story in qa stage: {response}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// -- handle_assign (with running coder) ----------------------------------
|
||
|
|
|
||
|
|
#[tokio::test]
|
||
|
|
async fn handle_assign_stops_running_coder_and_reports_reassignment() {
|
||
|
|
let tmp = tempfile::tempdir().unwrap();
|
||
|
|
write_story_file(
|
||
|
|
tmp.path(),
|
||
|
|
"2_current",
|
||
|
|
"10_story_current.md",
|
||
|
|
"---\nname: Current Story\nagent: coder-sonnet\n---\n",
|
||
|
|
);
|
||
|
|
|
||
|
|
let agents = std::sync::Arc::new(AgentPool::new_test(3000));
|
||
|
|
// Inject a running coder for this story.
|
||
|
|
agents.inject_test_agent("10_story_current", "coder-sonnet", AgentStatus::Running);
|
||
|
|
|
||
|
|
let response = handle_assign("Timmy", "10", "opus", tmp.path(), &agents).await;
|
||
|
|
|
||
|
|
// The response should mention both stopped and started agents.
|
||
|
|
assert!(
|
||
|
|
response.contains("coder-sonnet"),
|
||
|
|
"response should mention the stopped agent: {response}"
|
||
|
|
);
|
||
|
|
// Should indicate a restart occurred (not just "will be used when starts")
|
||
|
|
assert!(
|
||
|
|
response.to_lowercase().contains("stop") || response.to_lowercase().contains("reassign"),
|
||
|
|
"response should indicate stop/reassign: {response}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|