feat(directives): strict orchestration flow + sidebar overhaul + task page rewritestrict-orchestration

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>

1 files changed, 185 insertions, 0 deletions

diff --git a/makima/src/db/repository.rs b/makima/src/db/repository.rs
index 20f3268..ee4b561 100644
--- a/makima/src/db/repository.rs
+++ b/makima/src/db/repository.rs
@@ -6132,6 +6132,11 @@ pub async fn archive_directive_document(
 /// or queue it. Returns the updated row, or `Ok(None)` if the contract
 /// doesn't exist. Errors with `RepositoryError::Validation` if the
 /// contract is in any state other than `draft`.
+///
+/// Side effect: if the contract enters `active`, the parent directive
+/// is flipped to `active` (from `draft|paused|idle|inactive`). This is
+/// what makes the orchestrator reconciler pick the directive up — its
+/// gate is `directive.status = 'active' AND orchestrator_task_id IS NULL`.
 pub async fn start_contract(
     pool: &PgPool,
     contract_id: Uuid,
@@ -6184,6 +6189,13 @@ pub async fn start_contract(
     .fetch_optional(&mut *tx)
     .await?;
 
+    // Flip the parent directive to active so the reconciler picks it up.
+    // Only when this contract is actually entering the active slot — a
+    // queued contract doesn't drive planning by itself.
+    if new_status == "active" {
+        activate_parent_directive(&mut tx, current.directive_id).await?;
+    }
+
     tx.commit().await?;
     Ok(updated)
 }
@@ -6234,6 +6246,16 @@ pub async fn pause_contract(
     // position, excluding the one we just paused).
     promote_next_queued_contract(&mut tx, current.directive_id).await?;
 
+    // If no contract is active after the pause+promote, pause the
+    // directive too — stops the reconciler from spawning new planners
+    // on what is now an idle directive.
+    deactivate_parent_directive_if_no_active(
+        &mut tx,
+        current.directive_id,
+        "paused",
+    )
+    .await?;
+
     tx.commit().await?;
     Ok(updated)
 }
@@ -6289,6 +6311,17 @@ pub async fn complete_contract(
 
     promote_next_queued_contract(&mut tx, current.directive_id).await?;
 
+    // If the ship freed the active slot AND no queued contract was
+    // available to promote, the directive itself goes inactive — its
+    // iteration is shipped; the next cycle starts via reopen or a new
+    // contract.
+    deactivate_parent_directive_if_no_active(
+        &mut tx,
+        current.directive_id,
+        "inactive",
+    )
+    .await?;
+
     tx.commit().await?;
     Ok(updated)
 }
@@ -6339,12 +6372,164 @@ pub async fn unlock_contract(
 
     if was_active {
         promote_next_queued_contract(&mut tx, current.directive_id).await?;
+        // If unlocking the active contract leaves no other active under
+        // the directive, pause the directive too.
+        deactivate_parent_directive_if_no_active(
+            &mut tx,
+            current.directive_id,
+            "paused",
+        )
+        .await?;
     }
 
     tx.commit().await?;
     Ok(updated)
 }
 
+/// Reopen a shipped contract for amendment. Flips the contract back to
+/// `active`, re-activates the parent directive, and clears the
+/// directive's PR linkage + orchestrator task so the reconciler spawns a
+/// fresh planner. The planner uses `get_latest_merged_revision` to
+/// detect the previously-shipped PR and frame the new plan as a delta.
+pub async fn reopen_contract(
+    pool: &PgPool,
+    contract_id: Uuid,
+) -> Result<Option<DirectiveDocument>, RepositoryError> {
+    let mut tx = pool.begin().await?;
+
+    let current = sqlx::query_as::<_, DirectiveDocument>(
+        r#"SELECT * FROM directive_documents WHERE id = $1"#,
+    )
+    .bind(contract_id)
+    .fetch_optional(&mut *tx)
+    .await?;
+
+    let current = match current {
+        Some(c) => c,
+        None => return Ok(None),
+    };
+
+    if current.status != "shipped" {
+        return Err(RepositoryError::Validation(format!(
+            "contract is in status '{}'; only 'shipped' contracts can be reopened",
+            current.status
+        )));
+    }
+
+    let updated = sqlx::query_as::<_, DirectiveDocument>(
+        r#"
+        UPDATE directive_documents
+           SET status = 'active',
+               version = version + 1,
+               updated_at = NOW()
+         WHERE id = $1
+        RETURNING *
+        "#,
+    )
+    .bind(contract_id)
+    .fetch_optional(&mut *tx)
+    .await?;
+
+    // Re-activate the directive and clear the prior PR + orchestrator
+    // linkage. Status is forced to `active` regardless of prior value
+    // (except archived — guard against re-opening under an archived
+    // directive).
+    sqlx::query(
+        r#"
+        UPDATE directives
+           SET status = 'active',
+               orchestrator_task_id = NULL,
+               pr_url = NULL,
+               pr_branch = NULL,
+               updated_at = NOW(),
+               version = version + 1
+         WHERE id = $1 AND status <> 'archived'
+        "#,
+    )
+    .bind(current.directive_id)
+    .execute(&mut *tx)
+    .await?;
+
+    tx.commit().await?;
+    Ok(updated)
+}
+
+/// Resolve the directive's currently-active contract id. Returns
+/// `Ok(None)` when no active contract exists. Used by the
+/// auto-complete-on-PR path so the contract row can be shipped at the
+/// same moment the directive registers its PR url.
+pub async fn get_active_contract_id_for_directive(
+    pool: &PgPool,
+    directive_id: Uuid,
+) -> Result<Option<Uuid>, sqlx::Error> {
+    let row: Option<(Uuid,)> = sqlx::query_as(
+        r#"
+        SELECT id FROM directive_documents
+         WHERE directive_id = $1 AND status = 'active'
+         ORDER BY position ASC, created_at ASC
+         LIMIT 1
+        "#,
+    )
+    .bind(directive_id)
+    .fetch_optional(pool)
+    .await?;
+    Ok(row.map(|r| r.0))
+}
+
+/// Flip the parent directive to `active` when a child contract just
+/// became active. Only promotes from `draft|paused|idle|inactive` —
+/// leaves `archived` directives untouched.
+async fn activate_parent_directive(
+    tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    directive_id: Uuid,
+) -> Result<(), sqlx::Error> {
+    sqlx::query(
+        r#"
+        UPDATE directives
+           SET status = 'active',
+               updated_at = NOW(),
+               version = version + 1
+         WHERE id = $1
+           AND status IN ('draft', 'paused', 'idle', 'inactive')
+        "#,
+    )
+    .bind(directive_id)
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
+/// After a contract lifecycle change that may have left no active
+/// contract under the directive, transition the directive to the
+/// supplied `new_status` (typically `'paused'` for unlock/pause flows,
+/// `'inactive'` for ship). No-op if the directive still has an active
+/// contract or is already past the destination state.
+async fn deactivate_parent_directive_if_no_active(
+    tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    directive_id: Uuid,
+    new_status: &str,
+) -> Result<(), sqlx::Error> {
+    sqlx::query(
+        r#"
+        UPDATE directives
+           SET status = $2,
+               updated_at = NOW(),
+               version = version + 1
+         WHERE id = $1
+           AND status = 'active'
+           AND NOT EXISTS (
+               SELECT 1 FROM directive_documents
+                WHERE directive_id = $1 AND status = 'active'
+           )
+        "#,
+    )
+    .bind(directive_id)
+    .bind(new_status)
+    .execute(&mut **tx)
+    .await?;
+    Ok(())
+}
+
 /// Find the lowest-position `queued` contract under a directive and
 /// flip it to `active`. No-op when no queued contract exists.
 ///