diff options
Diffstat (limited to 'makima/src/orchestration/directive.rs')
| -rw-r--r-- | makima/src/orchestration/directive.rs | 229 |
1 files changed, 64 insertions, 165 deletions
diff --git a/makima/src/orchestration/directive.rs b/makima/src/orchestration/directive.rs index 1e004bf..80d8172 100644 --- a/makima/src/orchestration/directive.rs +++ b/makima/src/orchestration/directive.rs @@ -18,11 +18,22 @@ use crate::server::state::{DaemonCommand, SharedState}; pub struct DirectiveOrchestrator { pool: PgPool, state: SharedState, + /// Last time we ran the tmp-task expiry sweep. Throttled to once an + /// hour so the deletion query doesn't run on every 15-second tick. + last_tmp_sweep: std::time::Instant, } impl DirectiveOrchestrator { pub fn new(pool: PgPool, state: SharedState) -> Self { - Self { pool, state } + Self { + pool, + state, + // Initialise to 1 hour ago so the first tick after startup runs + // the sweep immediately — clears any tasks that aged out while + // the server was down. + last_tmp_sweep: std::time::Instant::now() + - std::time::Duration::from_secs(3600), + } } /// Run one orchestration tick — called every 15s. @@ -42,6 +53,14 @@ impl DirectiveOrchestrator { if let Err(e) = self.phase_completion().await { tracing::warn!(error = %e, "Directive phase_completion failed"); } + // Throttled to hourly — the actual delete is cheap (indexed + // partial scan) but we don't want to log a sweep every 15s. + if self.last_tmp_sweep.elapsed() >= std::time::Duration::from_secs(3600) { + self.last_tmp_sweep = std::time::Instant::now(); + if let Err(e) = self.phase_tmp_expiry().await { + tracing::warn!(error = %e, "Directive phase_tmp_expiry failed"); + } + } Ok(()) } @@ -100,40 +119,18 @@ impl DirectiveOrchestrator { let steps = repository::get_ready_steps_for_dispatch(&self.pool).await?; for step in steps { - // If the step has a contract_type, create a contract instead of a standalone task + // contract_type used to spawn a heavyweight contract+supervisor + // for a step. The contracts subsystem has been removed (Phase 5); + // we now treat any contract-backed step as a plain standalone + // task. The column itself is left in place for one more release + // so old data still reads cleanly, but it has no effect. if step.contract_type.is_some() { - tracing::info!( + tracing::warn!( step_id = %step.step_id, directive_id = %step.directive_id, - step_name = %step.step_name, contract_type = ?step.contract_type, - "Spawning contract for contract-backed step" + "Step has legacy contract_type; falling back to standalone task spawn" ); - - match self - .spawn_step_contract( - step.step_id, - step.directive_id, - step.owner_id, - &step.step_name, - step.step_description.as_deref(), - step.task_plan.as_deref(), - step.contract_type.as_deref().unwrap_or("simple"), - step.repository_url.as_deref(), - step.base_branch.as_deref(), - ) - .await - { - Ok(()) => {} - Err(e) => { - tracing::warn!( - step_id = %step.step_id, - error = %e, - "Failed to spawn contract for step" - ); - } - } - continue; } tracing::info!( @@ -647,141 +644,9 @@ impl DirectiveOrchestrator { Ok(()) } - /// Spawn a contract for a contract-backed step. - /// Creates a contract, adds the directive's repository to it, links it to the step, - /// creates a supervisor task, and marks the step as running. - async fn spawn_step_contract( - &self, - step_id: Uuid, - directive_id: Uuid, - owner_id: Uuid, - step_name: &str, - step_description: Option<&str>, - task_plan: Option<&str>, - contract_type: &str, - repo_url: Option<&str>, - base_branch: Option<&str>, - ) -> Result<(), anyhow::Error> { - // Build contract description from step info - let description = match (step_description, task_plan) { - (Some(desc), Some(plan)) => Some(format!("{}\n\n{}", desc, plan)), - (Some(desc), None) => Some(desc.to_string()), - (None, Some(plan)) => Some(plan.to_string()), - (None, None) => None, - }; - - // Create the contract - let contract_req = CreateContractRequest { - name: step_name.to_string(), - description, - contract_type: Some(contract_type.to_string()), - template_id: None, - initial_phase: None, - autonomous_loop: Some(true), - phase_guard: None, - local_only: None, - auto_merge_local: None, - }; - - let contract = repository::create_contract_for_owner(&self.pool, owner_id, contract_req).await?; - - tracing::info!( - step_id = %step_id, - contract_id = %contract.id, - contract_type = %contract.contract_type, - "Created contract for directive step" - ); - - // Link the contract to the step - repository::link_contract_to_step(&self.pool, step_id, contract.id).await?; - - // Add the directive's repository to the contract (if available) - if let Some(url) = repo_url { - if let Err(e) = repository::add_remote_repository( - &self.pool, - contract.id, - step_name, - url, - true, // is_primary - ) - .await - { - tracing::warn!( - contract_id = %contract.id, - error = %e, - "Failed to add repository to contract — continuing without it" - ); - } - } - - // Create supervisor task for the contract (following the pattern from contract handlers) - let supervisor_name = format!("{} Supervisor", step_name); - let supervisor_plan = format!( - "You are the supervisor for contract '{}'. Your goal is to drive this contract to completion.\n\n{}", - step_name, - contract.description.as_deref().unwrap_or("No description provided.") - ); - - let supervisor_req = CreateTaskRequest { - name: supervisor_name.clone(), - description: None, - plan: supervisor_plan.clone(), - repository_url: repo_url.map(|s| s.to_string()), - base_branch: base_branch.map(|s| s.to_string()), - target_branch: None, - parent_task_id: None, - contract_id: Some(contract.id), - target_repo_path: None, - completion_action: None, - continue_from_task_id: None, - copy_files: None, - is_supervisor: true, - checkpoint_sha: None, - priority: 0, - merge_mode: None, - branched_from_task_id: None, - conversation_history: None, - supervisor_worktree_task_id: None, - directive_id: Some(directive_id), - directive_step_id: Some(step_id), - }; - - let supervisor_task = repository::create_task_for_owner(&self.pool, owner_id, supervisor_req).await?; - - tracing::info!( - contract_id = %contract.id, - supervisor_task_id = %supervisor_task.id, - "Created supervisor task for contract-backed step" - ); - - // Link supervisor task to contract - let update_req = UpdateContractRequest { - supervisor_task_id: Some(supervisor_task.id), - version: Some(contract.version), - ..Default::default() - }; - if let Err(e) = repository::update_contract_for_owner(&self.pool, contract.id, owner_id, update_req).await { - tracing::warn!( - contract_id = %contract.id, - error = %e, - "Failed to link supervisor task to contract" - ); - } - - // Try to dispatch the supervisor task to a daemon - if self - .try_dispatch_task(supervisor_task.id, owner_id, &supervisor_task.name, &supervisor_task.plan, supervisor_task.version) - .await - { - repository::set_step_running(&self.pool, step_id).await?; - } else { - // Even if dispatch fails, mark step as running since contract is created. - // The supervisor task will be retried by the pending task retry logic. - repository::set_step_running(&self.pool, step_id).await?; - } - - Ok(()) - } + // spawn_step_contract was removed in Phase 5 — the contracts subsystem + // is gone. Step rows with `contract_type` set are now silently treated + // as standalone tasks (see the warn! in phase_execution). /// Try to dispatch a task to an available daemon. Returns true if dispatched. async fn try_dispatch_task( @@ -877,6 +742,40 @@ impl DirectiveOrchestrator { false } + /// Hourly sweep — delete top-level tasks attached to any tmp directive + /// that are older than 30 days. Per-owner; no global cap. Subtasks die + /// via the FK cascade. + async fn phase_tmp_expiry(&self) -> Result<(), anyhow::Error> { + let tmps = repository::list_all_tmp_directives(&self.pool).await?; + let mut total_deleted: u64 = 0; + for d in tmps { + match repository::delete_expired_tmp_tasks(&self.pool, d.id).await { + Ok(n) => { + if n > 0 { + tracing::info!( + directive_id = %d.id, + owner_id = %d.owner_id, + deleted = n, + "Expired tmp tasks deleted (>30 days old)" + ); + total_deleted += n; + } + } + Err(e) => { + tracing::warn!( + directive_id = %d.id, + error = %e, + "Failed to expire tmp tasks for owner" + ); + } + } + } + if total_deleted > 0 { + tracing::info!(total = total_deleted, "Tmp expiry sweep completed"); + } + Ok(()) + } + /// Phase 5: Completion — spawn PR-creation tasks for idle directives. async fn phase_completion(&self) -> Result<(), anyhow::Error> { // Part 1: Spawn completion tasks for idle directives |