feat(directives): strict orchestration flow + sidebar overhaul + task page rewrite (#134)

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: <title>"      → "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>

2 files changed, 96 insertions, 43 deletions

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"
+                            );
+                        }
                     }
                 }
             }