Method execute

src/commands/run.rs:20–95

(&self, ctx: &AppContext)

#[async_trait]
impl Command for RunCommand {
    async fn execute(&self, ctx: &AppContext) -> Result<(), Box<dyn Error>> {
        let args = &self.task_args;
        let name = args.resolved_name();

        let agents = args.parse_and_validate_agents()?;

        // Run command only supports single agent (no multi-agent execution)
        if agents.len() > 1 {
            return Err(
                "Run command only supports a single agent. Use 'tsk add' for multi-agent tasks."
                    .into(),
            );
        }

        let prompt = args.resolve_prompt()?;
        let repo_root = args.resolve_repo_root()?;

        let task = args
            .configure_builder(repo_root, name.clone(), Some(agents[0].clone()), prompt)
            .build(ctx)
            .await?;

        println!(
            "Running {} ({}, {}, {}){}",
            task.id,
            task.task_type,
            task.stack,
            task.agent,
            args.branch_suffix()
        );

        // Update terminal title for the task
        ctx.terminal_operations().set_title(&format!("TSK: {name}"));

        // Execute the task
        let docker_client: Arc<dyn crate::context::docker_client::DockerClient> =
            match &self.docker_client_override {
                Some(client) => Arc::clone(client),
                None => Arc::new(
                    DefaultDockerClient::new(&ctx.tsk_config().container_engine)
                        .map_err(|e| -> Box<dyn Error> { e.into() })?,
                ),
            };
        let docker_manager = DockerManager::new(ctx, docker_client.clone(), None);
        let task_runner = TaskRunner::new(ctx, docker_manager, None);

        // Set up signal handler for Ctrl+C cancellation
        let storage = ctx.task_storage();
        let task_id = task.id.clone();
        let container_name = format!("tsk-{}", task.id);
        let cancel_client = docker_client.clone();
        let cancel_storage = storage.clone();

        tokio::spawn(async move {
            let mut sigterm =
                signal(SignalKind::terminate()).expect("Failed to listen for SIGTERM");
            tokio::select! {
                _ = tokio::signal::ctrl_c() => {},