From 8cd7b40ace4e5e2b22ad89aafec74c7655def19b Mon Sep 17 00:00:00 2001 From: soryu Date: Sat, 16 May 2026 19:55:34 +0100 Subject: feat(directives): strict orchestration flow + sidebar overhaul + task page rewrite MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit End-to-end rewrite addressing the issues from the user's UX review. The system now feels like a daemon-orchestration tool: lock a contract and the orchestrator just goes; PR raised → auto-ship → reopen for amendments. The sidebar tree shows real entities only (no duplicates, no inline action buttons polluting the file list), and every entity gets a right-click context menu. Task page matches the old /exec layout (diff on the left, feed + composer on the right). ## Backend — strict lifecycle (the orchestrator-never-spawned bug) Root cause: `phase_planning()` gates on `directive.status='active'`, but `start_contract()` only flipped the contract row — the parent directive stayed in whatever state it was. So locking a contract did nothing visible. Fix: contract lifecycle now drives directive status in the same transaction. start_contract → if contract becomes active, flip directive draft|paused|idle|inactive → active pause_contract → after promote, if no active contract left, directive → paused complete_contract→ after promote, if no active left, directive → inactive (also fires on auto-ship from PR detect) unlock_contract → if was active and no active left, directive → paused reopen_contract → NEW. shipped → active. Directive → active, orchestrator_task_id/pr_url/pr_branch cleared so the reconciler spawns a fresh planner. The planner reads get_latest_merged_revision and frames the new plan as an amendment. handlers::directive_documents lifts state.kick_directive_reconciler() into run_contract_transition so every successful transition wakes the reconciler immediately (no 15s wait). handlers::directives `update_directive` (PR-detection branch) calls `complete_contract(active_contract_id, pr_url, pr_branch)` instead of `set_directive_inactive`. The contract auto-ships; the directive follows via the sync above. No more manual "Mark complete" click. POST /api/v1/contracts/{id}/reopen added + wired through openapi. Spawn task names dropped the directive-title prefix that looked redundant in the sidebar: "Plan: " → "orchestrator" "Re-plan: <title>" → "orchestrator (re-plan)" "PR: <title>" → "completion" "Update PR: <title>" → "completion (update)" ## Frontend — sidebar * De-dupe: DocumentTasksFolder filters tasks[] to exclude any task whose id already appears in steps[].taskId. Single row per task, single highlight on click. * Generic SidebarContextMenu (new) replaces the directive-only DirectiveContextMenu (deleted). Per-entity item arrays built at the page level — directive, contract, step, task each have their own contextual actions. * Right-click works on every sidebar entity now (was directive-only). * `+ New document` / `+ New ephemeral task` inline buttons removed. Reachable via the directive folder right-click OR the hover-only `+` button on the directive folder row. * ContractHeader: dropped "Mark complete" button (auto-fires on PR). Added "Reopen for amendment" button when contract is shipped. ## Frontend — task page rewrite TaskPage.tsx replaces DocumentTaskStream.tsx (deleted). Two-column layout matches the old /exec page that the user preferred: ┌────────────────────────┬──────────────────────────────────┐ │ Changed files (~30%) │ Transcript feed (scrollable) │ │ ────────────────── │ ────────────────────── │ │ src/foo.rs │ [user] do thing │ │ src/bar.rs │ [tool] Read foo.rs │ │ │ │ │ Diff (selected file) │ │ │ ├──────────────────────────────────┤ │ │ Composer (sticky bottom) │ └────────────────────────┴──────────────────────────────────┘ Diff comes from getTaskDiff(); parseDiff + DiffFileView exported from OverlayDiffViewer for reuse (no duplication). Diff auto-refreshes when the task transitions to a terminal state. Transcript styling + sticky composer keep the parts the user liked. "Open in task page" button removed — the right pane IS the task page. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --- makima/src/server/handlers/directive_documents.rs | 85 ++++++++++++++--------- makima/src/server/handlers/directives.rs | 54 +++++++++++--- makima/src/server/mod.rs | 4 ++ makima/src/server/openapi.rs | 1 + 4 files changed, 101 insertions(+), 43 deletions(-) (limited to 'makima/src/server') diff --git a/makima/src/server/handlers/directive_documents.rs b/makima/src/server/handlers/directive_documents.rs index 23081b5..ee98a61 100644 --- a/makima/src/server/handlers/directive_documents.rs +++ b/makima/src/server/handlers/directive_documents.rs @@ -680,7 +680,7 @@ pub async fn reorder_contract( /// closure. Cuts the boilerplate from start/pause/complete/unlock down /// to a couple of lines each. async fn run_contract_transition<F, Fut>( - pool: sqlx::PgPool, + state: SharedState, owner_id: Uuid, contract_id: Uuid, f: F, @@ -691,6 +691,14 @@ where Output = Result<Option<crate::db::models::DirectiveDocument>, RepositoryError>, >, { + let Some(pool) = state.db_pool.clone() else { + return ( + StatusCode::SERVICE_UNAVAILABLE, + Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), + ) + .into_response(); + }; + match load_owned_document(&pool, owner_id, contract_id).await { Ok(Some(_)) => {} Ok(None) => { @@ -710,7 +718,14 @@ where } match f(pool, contract_id).await { - Ok(Some(doc)) => Json(doc).into_response(), + Ok(Some(doc)) => { + // Any successful lifecycle transition may have flipped the + // parent directive's status (see repository helpers). Wake + // the reconciler so the user doesn't wait up to 15s before + // the orchestrator daemon spawns / stops. + state.kick_directive_reconciler(); + Json(doc).into_response() + } Ok(None) => ( StatusCode::NOT_FOUND, Json(ApiError::new("NOT_FOUND", "Contract not found")), @@ -759,14 +774,7 @@ pub async fn start_contract( Authenticated(auth): Authenticated, Path(document_id): Path<Uuid>, ) -> impl IntoResponse { - let Some(pool) = state.db_pool.clone() else { - return ( - StatusCode::SERVICE_UNAVAILABLE, - Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), - ) - .into_response(); - }; - run_contract_transition(pool, auth.owner_id, document_id, |pool, id| async move { + run_contract_transition(state, auth.owner_id, document_id, |pool, id| async move { repository::start_contract(&pool, id).await }) .await @@ -793,14 +801,7 @@ pub async fn pause_contract( Authenticated(auth): Authenticated, Path(document_id): Path<Uuid>, ) -> impl IntoResponse { - let Some(pool) = state.db_pool.clone() else { - return ( - StatusCode::SERVICE_UNAVAILABLE, - Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), - ) - .into_response(); - }; - run_contract_transition(pool, auth.owner_id, document_id, |pool, id| async move { + run_contract_transition(state, auth.owner_id, document_id, |pool, id| async move { repository::pause_contract(&pool, id).await }) .await @@ -829,14 +830,7 @@ pub async fn complete_contract( Path(document_id): Path<Uuid>, Json(req): Json<CompleteContractRequest>, ) -> impl IntoResponse { - let Some(pool) = state.db_pool.clone() else { - return ( - StatusCode::SERVICE_UNAVAILABLE, - Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), - ) - .into_response(); - }; - run_contract_transition(pool, auth.owner_id, document_id, move |pool, id| async move { + run_contract_transition(state, auth.owner_id, document_id, move |pool, id| async move { repository::complete_contract(&pool, id, req.pr_url.as_deref(), req.pr_branch.as_deref()).await }) .await @@ -863,16 +857,39 @@ pub async fn unlock_contract( Authenticated(auth): Authenticated, Path(document_id): Path<Uuid>, ) -> impl IntoResponse { - let Some(pool) = state.db_pool.clone() else { - return ( - StatusCode::SERVICE_UNAVAILABLE, - Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")), - ) - .into_response(); - }; - run_contract_transition(pool, auth.owner_id, document_id, |pool, id| async move { + run_contract_transition(state, auth.owner_id, document_id, |pool, id| async move { repository::unlock_contract(&pool, id).await }) .await .into_response() } + +/// Reopen a shipped contract for amendment. The contract goes back to +/// `active`, the parent directive flips to `active`, and the directive's +/// PR linkage + orchestrator task id are cleared so the reconciler +/// spawns a fresh planner. The planner reads +/// `get_latest_merged_revision` and frames the new plan as a delta on +/// top of the previously-merged PR. +#[utoipa::path( + post, + path = "/api/v1/contracts/{document_id}/reopen", + params(("document_id" = Uuid, Path, description = "Contract ID")), + responses( + (status = 200, description = "Contract reopened", body = crate::db::models::DirectiveDocument), + (status = 400, description = "Invalid state transition", body = ApiError), + (status = 404, description = "Not found", body = ApiError), + ), + security(("bearer_auth" = []), ("api_key" = [])), + tag = "Directive Documents" +)] +pub async fn reopen_contract( + State(state): State<SharedState>, + Authenticated(auth): Authenticated, + Path(document_id): Path<Uuid>, +) -> impl IntoResponse { + run_contract_transition(state, auth.owner_id, document_id, |pool, id| async move { + repository::reopen_contract(&pool, id).await + }) + .await + .into_response() +} diff --git a/makima/src/server/handlers/directives.rs b/makima/src/server/handlers/directives.rs index 6d99179..35a46a0 100644 --- a/makima/src/server/handlers/directives.rs +++ b/makima/src/server/handlers/directives.rs @@ -232,15 +232,51 @@ pub async fn update_directive( ); } - // Transition the contract to 'inactive' now that its - // iteration is "shipped" — editing the goal again starts - // an amendment cycle, surfaced via the New draft action. - if let Err(e) = repository::set_directive_inactive(pool, directive.id).await { - tracing::warn!( - directive_id = %directive.id, - error = %e, - "Failed to mark directive inactive after PR creation" - ); + // Auto-complete the active contract — flips its status + // to `shipped`, records pr_url/pr_branch, and (via the + // contract↔directive sync in repository) transitions + // the directive itself to `inactive`. This removes the + // need for a manual "Mark complete" click; the PR + // raise IS the completion signal. + match repository::get_active_contract_id_for_directive(pool, directive.id).await { + Ok(Some(contract_id)) => { + if let Err(e) = repository::complete_contract( + pool, + contract_id, + Some(new_pr_url.as_str()), + directive.pr_branch.as_deref(), + ) + .await + { + tracing::warn!( + directive_id = %directive.id, + contract_id = %contract_id, + error = %e, + "Failed to auto-complete contract after PR creation — \ + directive status not synced; user may need to manually ship" + ); + } + } + Ok(None) => { + // No active contract — fall back to the old + // behaviour (mark directive inactive). This is + // the legacy path for directives without + // contracts attached yet. + if let Err(e) = repository::set_directive_inactive(pool, directive.id).await { + tracing::warn!( + directive_id = %directive.id, + error = %e, + "Failed to mark directive inactive after PR creation" + ); + } + } + Err(e) => { + tracing::warn!( + directive_id = %directive.id, + error = %e, + "Failed to resolve active contract for auto-complete" + ); + } } } } diff --git a/makima/src/server/mod.rs b/makima/src/server/mod.rs index 604caea..a6c7787 100644 --- a/makima/src/server/mod.rs +++ b/makima/src/server/mod.rs @@ -256,6 +256,10 @@ pub fn make_router(state: SharedState) -> Router { "/contracts/{document_id}/unlock", post(directive_documents::unlock_contract), ) + .route( + "/contracts/{document_id}/reopen", + post(directive_documents::reopen_contract), + ) .route( "/contracts/{document_id}/tasks", get(directive_documents::list_document_tasks), diff --git a/makima/src/server/openapi.rs b/makima/src/server/openapi.rs index 437285f..5bbd0fe 100644 --- a/makima/src/server/openapi.rs +++ b/makima/src/server/openapi.rs @@ -127,6 +127,7 @@ use crate::server::messages::{ApiError, AudioEncoding, StartMessage, StopMessage directive_documents::pause_contract, directive_documents::complete_contract, directive_documents::unlock_contract, + directive_documents::reopen_contract, directive_documents::list_document_tasks, // Order endpoints orders::list_orders, -- cgit v1.2.3