feat(directives): drop directives.goal — orchestration reads contract body (#132)

Hard cut. The unified contracts surface owns spec text now; the
directive itself is just a folder. The orchestrator daemon reads the
active contract's body when it spawns, replans, or runs completion.

Schema (migration 20260510000000):
  - DROP TABLE directive_goal_history
  - ALTER TABLE directives DROP COLUMN goal
  - ALTER TABLE directives DROP COLUMN goal_updated_at

New repo helper:
  - get_active_contract_body(directive_id) — picks the
    active|queued|draft contract (in that order), most-recent first.

Backend cuts:
  - Directive / DirectiveSummary / CreateDirectiveRequest /
    UpdateDirectiveRequest lose goal & goalUpdatedAt.
  - CreateDirectiveRequest gains optional `contractBody` — when
    provided, create_directive_for_owner auto-creates a first contract
    with that body in the same transaction.
  - Removed: update_directive_goal, update_directive_goal_keep_orchestrator,
    save_directive_goal_history, get_directive_goal_history,
    DirectiveGoalHistory model, UpdateGoalRequest.
  - Removed handlers::directives::update_goal + the
    /directives/{id}/goal route.
  - orchestration::directive::build_planning_prompt /
    build_completion_prompt / build_order_pickup_prompt now take a
    `contract_body: &str` instead of `goal_history`. classify_goal_change
    + try_interrupt_planner_with_goal_edit + GoalChangeKind +
    GoalEditInterruptResult removed (they were only useful for the
    small-vs-large goal-edit interrupt cycle).

CLI:
  - `makima directive update-goal` removed (UpdateGoalArgs deleted,
    Commands enum trimmed, ApiClient::directive_update_goal +
    UpdateGoalRequest deleted).

Frontend:
  - Directive / DirectiveSummary / CreateDirectiveRequest types lose
    goal & goalUpdatedAt; CreateDirectiveRequest gains `contractBody`.
  - useDirective drops updateGoal helper.
  - api.ts updateDirectiveGoal removed.
  - Legacy DirectiveList + DirectiveDetail components deleted; the
    /directives route now always renders the document-mode page.
    The user-settings documentModeEnabled flag is no longer
    consulted at the route level.
  - NewContractModal passes body via contractBody.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

10 files changed, 163 insertions, 686 deletions

diff --git a/makima/src/bin/makima.rs b/makima/src/bin/makima.rs
index a84c581..7b8cdb6 100644
--- a/makima/src/bin/makima.rs
+++ b/makima/src/bin/makima.rs
@@ -417,13 +417,6 @@ async fn run_directive(
                 .await?;
             println!("{}", serde_json::to_string(&result.0)?);
         }
-        DirectiveCommand::UpdateGoal(args) => {
-            let client = ApiClient::new(args.common.api_url, args.common.api_key)?;
-            let result = client
-                .directive_update_goal(args.common.directive_id, &args.goal)
-                .await?;
-            println!("{}", serde_json::to_string(&result.0)?);
-        }
         DirectiveCommand::BatchAddSteps(args) => {
             let client = ApiClient::new(args.common.api_url, args.common.api_key)?;
             let steps: serde_json::Value = serde_json::from_str(&args.json)
diff --git a/makima/src/daemon/api/directive.rs b/makima/src/daemon/api/directive.rs
index 1088eb7..bf5db09 100644
--- a/makima/src/daemon/api/directive.rs
+++ b/makima/src/daemon/api/directive.rs
@@ -20,12 +20,6 @@ pub struct CreateStepRequest {
 
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct UpdateGoalRequest {
-    pub goal: String,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
 pub struct UpdateStepDepsRequest {
     pub depends_on: Vec<Uuid>,
 }
@@ -125,16 +119,6 @@ impl ApiClient {
         .await
     }
 
-    /// Update the directive's goal.
-    pub async fn directive_update_goal(
-        &self,
-        directive_id: Uuid,
-        goal: &str,
-    ) -> Result<JsonValue, ApiError> {
-        let req = UpdateGoalRequest { goal: goal.to_string() };
-        self.put(&format!("/api/v1/directives/{}/goal", directive_id), &req).await
-    }
-
     /// Update directive metadata (PR URL, PR branch, status, etc.)
     pub async fn directive_update(
         &self,
diff --git a/makima/src/daemon/cli/directive.rs b/makima/src/daemon/cli/directive.rs
index 0f04720..a27b94e 100644
--- a/makima/src/daemon/cli/directive.rs
+++ b/makima/src/daemon/cli/directive.rs
@@ -90,15 +90,7 @@ pub struct StepActionArgs {
     pub step_id: Uuid,
 }
 
-/// Arguments for update-goal command.
-#[derive(Args, Debug)]
-pub struct UpdateGoalArgs {
-    #[command(flatten)]
-    pub common: DirectiveArgs,
-
-    /// New goal text
-    pub goal: String,
-}
+// (UpdateGoalArgs removed — spec edits flow through the contracts API now.)
 
 /// Arguments for batch-add-steps command.
 #[derive(Args, Debug)]
diff --git a/makima/src/daemon/cli/mod.rs b/makima/src/daemon/cli/mod.rs
index b01c161..acad9ad 100644
--- a/makima/src/daemon/cli/mod.rs
+++ b/makima/src/daemon/cli/mod.rs
@@ -107,9 +107,6 @@ pub enum DirectiveCommand {
     /// Mark a step as skipped
     SkipStep(directive::StepActionArgs),
 
-    /// Update the directive's goal (triggers re-planning)
-    UpdateGoal(directive::UpdateGoalArgs),
-
     /// Batch add multiple steps from JSON
     BatchAddSteps(directive::BatchAddStepsArgs),
 
diff --git a/makima/src/db/models.rs b/makima/src/db/models.rs
index fcccd05..3fb9667 100644
--- a/makima/src/db/models.rs
+++ b/makima/src/db/models.rs
@@ -2704,14 +2704,16 @@ mod tests {
 // Directive Types
 // =============================================================================
 
-/// A directive — a long-lived top-level entity for managing projects via a DAG of steps.
+/// A directive — a long-lived top-level entity that owns a sequence of
+/// contracts (see `directive_documents`). The directive itself is a
+/// folder; the active contract's body is the spec the orchestrator
+/// daemon reads when planning.
 #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct Directive {
     pub id: Uuid,
     pub owner_id: Uuid,
     pub title: String,
-    pub goal: String,
     /// Status: draft, active, idle, paused, archived
     pub status: String,
     pub repository_url: Option<String>,
@@ -2723,7 +2725,6 @@ pub struct Directive {
     pub completion_task_id: Option<Uuid>,
     /// Question timeout mode: "auto" (30s timeout), "semi-auto" (block indefinitely), "manual" (block + ask many questions)
     pub reconcile_mode: String,
-    pub goal_updated_at: DateTime<Utc>,
     pub started_at: Option<DateTime<Utc>>,
     pub version: i32,
     pub created_at: DateTime<Utc>,
@@ -2736,16 +2737,6 @@ pub struct Directive {
     pub is_tmp: bool,
 }
 
-/// A historical record of a directive goal change.
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct DirectiveGoalHistory {
-    pub id: Uuid,
-    pub directive_id: Uuid,
-    pub goal: String,
-    pub created_at: DateTime<Utc>,
-}
-
 /// Per-PR snapshot of a directive's goal — the immutable record of what the
 /// contract said at the moment a PR was raised. Frozen at PR-creation time;
 /// `pr_state` mirrors the PR's GitHub lifecycle ('open' | 'merged' | 'closed').
@@ -2808,7 +2799,6 @@ pub struct DirectiveSummary {
     pub id: Uuid,
     pub owner_id: Uuid,
     pub title: String,
-    pub goal: String,
     pub status: String,
     pub repository_url: Option<String>,
     pub orchestrator_task_id: Option<Uuid>,
@@ -2833,12 +2823,18 @@ pub struct DirectiveListResponse {
     pub total: i64,
 }
 
-/// Request to create a new directive.
+/// Request to create a new directive. The directive itself has no spec
+/// text — pass `contractBody` to auto-create a first contract whose
+/// body is the spec; if omitted, the directive is created empty and
+/// the user will create a contract from the UI.
 #[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateDirectiveRequest {
     pub title: String,
-    pub goal: String,
+    /// Optional. When provided, a first contract is auto-created with
+    /// this body so the directive is immediately ready to start.
+    #[serde(default)]
+    pub contract_body: Option<String>,
     pub repository_url: Option<String>,
     pub local_path: Option<String>,
     pub base_branch: Option<String>,
@@ -2846,12 +2842,13 @@ pub struct CreateDirectiveRequest {
     pub reconcile_mode: Option<String>,
 }
 
-/// Request to update a directive.
+/// Request to update a directive's metadata. Spec edits go through the
+/// contracts API now — this endpoint only mutates directive-level
+/// fields (title, repo, status, etc.).
 #[derive(Debug, Default, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct UpdateDirectiveRequest {
     pub title: Option<String>,
-    pub goal: Option<String>,
     pub status: Option<String>,
     pub repository_url: Option<String>,
     pub local_path: Option<String>,
@@ -2864,13 +2861,6 @@ pub struct UpdateDirectiveRequest {
     pub version: Option<i32>,
 }
 
-/// Request to update a directive's goal (triggers re-planning).
-#[derive(Debug, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateGoalRequest {
-    pub goal: String,
-}
-
 /// Response for cleanup_directive_tasks (legacy).
 #[derive(Debug, Serialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
diff --git a/makima/src/db/repository.rs b/makima/src/db/repository.rs
index e58f58c..20f3268 100644
--- a/makima/src/db/repository.rs
+++ b/makima/src/db/repository.rs
@@ -12,7 +12,7 @@ use super::models::{
     CreateContractRequest, CreateFileRequest, CreateTaskRequest,
     CreateTemplateRequest, Daemon, DaemonTaskAssignment, DaemonWithCapacity,
     DeliverableDefinition, Directive, DirectiveDocument, DirectiveStep, DirectiveSummary,
-    CreateDirectiveRequest, CreateDirectiveStepRequest, DirectiveGoalHistory,
+    CreateDirectiveRequest, CreateDirectiveStepRequest,
     UpdateDirectiveRequest, UpdateDirectiveStepRequest,
     CreateOrderRequest, Order, UpdateOrderRequest,
     CreateDirectiveOrderGroupRequest, DirectiveOrderGroup, UpdateDirectiveOrderGroupRequest,
@@ -5125,27 +5125,78 @@ fn truncate_string(s: &str, max_len: usize) -> String {
 // =============================================================================
 
 /// Create a new directive for an owner.
+///
+/// If `req.contract_body` is set, also auto-creates a first contract
+/// with that body so the directive is immediately ready to start. Both
+/// inserts run in the same transaction.
 pub async fn create_directive_for_owner(
     pool: &PgPool,
     owner_id: Uuid,
     req: CreateDirectiveRequest,
 ) -> Result<Directive, sqlx::Error> {
-    sqlx::query_as::<_, Directive>(
+    let mut tx = pool.begin().await?;
+
+    let directive = sqlx::query_as::<_, Directive>(
         r#"
-        INSERT INTO directives (owner_id, title, goal, repository_url, local_path, base_branch, reconcile_mode)
-        VALUES ($1, $2, $3, $4, $5, $6, $7)
+        INSERT INTO directives (owner_id, title, repository_url, local_path, base_branch, reconcile_mode)
+        VALUES ($1, $2, $3, $4, $5, $6)
         RETURNING *
         "#,
     )
     .bind(owner_id)
     .bind(&req.title)
-    .bind(&req.goal)
     .bind(&req.repository_url)
     .bind(&req.local_path)
     .bind(&req.base_branch)
     .bind(req.reconcile_mode.as_deref().unwrap_or("auto"))
-    .fetch_one(pool)
-    .await
+    .fetch_one(&mut *tx)
+    .await?;
+
+    if let Some(body) = &req.contract_body {
+        sqlx::query(
+            r#"
+            INSERT INTO directive_documents (directive_id, title, body, status, position)
+            VALUES ($1, '', $2, 'draft', 0)
+            "#,
+        )
+        .bind(directive.id)
+        .bind(body)
+        .execute(&mut *tx)
+        .await?;
+    }
+
+    tx.commit().await?;
+    Ok(directive)
+}
+
+/// Resolve the body of the directive's "current spec" — the active
+/// contract's body, falling back to the most-recently-updated draft if
+/// none is active. Returns empty string when the directive has no
+/// usable contracts (orchestrator should refuse to spawn in that case).
+pub async fn get_active_contract_body(
+    pool: &PgPool,
+    directive_id: Uuid,
+) -> Result<String, sqlx::Error> {
+    let row: Option<(String,)> = sqlx::query_as(
+        r#"
+        SELECT body FROM directive_documents
+         WHERE directive_id = $1
+           AND status IN ('active', 'queued', 'draft')
+         ORDER BY
+             CASE status
+                 WHEN 'active' THEN 0
+                 WHEN 'queued' THEN 1
+                 WHEN 'draft'  THEN 2
+                 ELSE 3
+             END,
+             updated_at DESC
+         LIMIT 1
+        "#,
+    )
+    .bind(directive_id)
+    .fetch_optional(pool)
+    .await?;
+    Ok(row.map(|r| r.0).unwrap_or_default())
 }
 
 /// Get a single directive for an owner.
@@ -5212,7 +5263,7 @@ pub async fn list_directives_for_owner(
     sqlx::query_as::<_, DirectiveSummary>(
         r#"
         SELECT
-            d.id, d.owner_id, d.title, d.goal, d.status, d.repository_url,
+            d.id, d.owner_id, d.title, d.status, d.repository_url,
             d.orchestrator_task_id, d.pr_url, d.completion_task_id,
             d.reconcile_mode,
             d.version, d.created_at, d.updated_at,
@@ -5271,8 +5322,6 @@ pub async fn update_directive_for_owner(
     }
 
     let title = req.title.as_deref().unwrap_or(&current.title);
-    let goal = req.goal.as_deref().unwrap_or(&current.goal);
-    let goal_changed = goal != current.goal;
     let status = req.status.as_deref().unwrap_or(&current.status);
     let repository_url = req.repository_url.as_deref().or(current.repository_url.as_deref());
     let local_path = req.local_path.as_deref().or(current.local_path.as_deref());
@@ -5285,10 +5334,9 @@ pub async fn update_directive_for_owner(
     let result = sqlx::query_as::<_, Directive>(
         r#"
         UPDATE directives
-        SET title = $3, goal = $4, status = $5, repository_url = $6, local_path = $7,
-            base_branch = $8, orchestrator_task_id = $9, pr_url = $10, pr_branch = $11,
-            reconcile_mode = $12,
-            goal_updated_at = CASE WHEN $13 THEN NOW() ELSE goal_updated_at END,
+        SET title = $3, status = $4, repository_url = $5, local_path = $6,
+            base_branch = $7, orchestrator_task_id = $8, pr_url = $9, pr_branch = $10,
+            reconcile_mode = $11,
             version = version + 1, updated_at = NOW()
         WHERE id = $1 AND owner_id = $2
         RETURNING *
@@ -5297,7 +5345,6 @@ pub async fn update_directive_for_owner(
     .bind(id)
     .bind(owner_id)
     .bind(title)
-    .bind(goal)
     .bind(status)
     .bind(repository_url)
     .bind(local_path)
@@ -5306,7 +5353,6 @@ pub async fn update_directive_for_owner(
     .bind(pr_url)
     .bind(pr_branch)
     .bind(reconcile_mode)
-    .bind(goal_changed)
     .fetch_optional(pool)
     .await
     .map_err(RepositoryError::Database)?;
@@ -6454,45 +6500,6 @@ pub async fn check_directive_idle(
     Ok(result.rows_affected() > 0)
 }
 
-/// Update a directive's goal and bump goal_updated_at.
-/// Reactivates draft/idle/paused/inactive directives and clears any stale
-/// orchestrator task so that planning/replanning triggers on the next
-/// reconciler tick.
-///
-/// `draft` flips because the document-mode UI treats the first goal save as
-/// the implicit "start". `inactive` flips because editing a contract whose
-/// last revision was already shipped is the way the user kicks off an
-/// amendment — the planner picks it up via phase_planning/replanning and
-/// uses get_latest_merged_revision to learn the BEFORE→AFTER diff.
-pub async fn update_directive_goal(
-    pool: &PgPool,
-    owner_id: Uuid,
-    directive_id: Uuid,
-    goal: &str,
-) -> Result<Option<Directive>, sqlx::Error> {
-    sqlx::query_as::<_, Directive>(
-        r#"
-        UPDATE directives
-        SET goal = $3,
-            goal_updated_at = NOW(),
-            status = CASE
-                WHEN status IN ('draft', 'idle', 'paused', 'inactive') THEN 'active'
-                ELSE status
-            END,
-            orchestrator_task_id = NULL,
-            updated_at = NOW(),
-            version = version + 1
-        WHERE id = $1 AND owner_id = $2
-        RETURNING *
-        "#,
-    )
-    .bind(directive_id)
-    .bind(owner_id)
-    .bind(goal)
-    .fetch_optional(pool)
-    .await
-}
-
 /// Mark a directive 'inactive'. Used at the moment a PR is raised — at that
 /// point the contract's current iteration is "shipped" and editing the goal
 /// (Stage 4) starts an amendment cycle. Idempotent: no-op if status is
@@ -6517,11 +6524,10 @@ pub async fn set_directive_inactive(
     Ok(())
 }
 
-/// Reset a directive for a "new draft" cycle: clear the goal back to empty,
-/// flip status to 'draft', and detach the current pr_url / pr_branch /
-/// orchestrator linkage so the next goal save starts fresh. Prior revisions
-/// remain in `directive_revisions` as the historical record. Used by the
-/// sidebar's "New draft" right-click on inactive contracts.
+/// Reset a directive for a "new draft" cycle: flip status to 'draft' and
+/// detach the current pr_url / pr_branch / orchestrator linkage so the
+/// next contract activation starts fresh. Prior revisions remain in
+/// `directive_revisions` as the historical record.
 pub async fn reset_directive_for_new_draft(
     pool: &PgPool,
     owner_id: Uuid,
@@ -6530,9 +6536,7 @@ pub async fn reset_directive_for_new_draft(
     sqlx::query_as::<_, Directive>(
         r#"
         UPDATE directives
-        SET goal = '',
-            goal_updated_at = NOW(),
-            status = 'draft',
+        SET status = 'draft',
             pr_url = NULL,
             pr_branch = NULL,
             orchestrator_task_id = NULL,
@@ -6549,40 +6553,6 @@ pub async fn reset_directive_for_new_draft(
     .await
 }
 
-/// Update a directive's goal WITHOUT clearing the orchestrator task id.
-///
-/// This is the path used by the goal-edit interrupt cycle: when a small goal
-/// edit arrives while a planner is already running, we want to keep the
-/// planner attached so a `SendMessage` can summarise the change in-flight
-/// instead of cancelling and respawning. We still bump `goal_updated_at` so
-/// the timestamp reflects the edit, but we do NOT trigger replanning by
-/// clearing the orchestrator task. We also do not flip status from
-/// idle/paused → active here, since by definition a planner is already
-/// running.
-pub async fn update_directive_goal_keep_orchestrator(
-    pool: &PgPool,
-    owner_id: Uuid,
-    directive_id: Uuid,
-    goal: &str,
-) -> Result<Option<Directive>, sqlx::Error> {
-    sqlx::query_as::<_, Directive>(
-        r#"
-        UPDATE directives
-        SET goal = $3,
-            goal_updated_at = NOW(),
-            updated_at = NOW(),
-            version = version + 1
-        WHERE id = $1 AND owner_id = $2
-        RETURNING *
-        "#,
-    )
-    .bind(directive_id)
-    .bind(owner_id)
-    .bind(goal)
-    .fetch_optional(pool)
-    .await
-}
-
 // =============================================================================
 // Directive Revisions — per-PR snapshots of the contract content.
 // =============================================================================
@@ -6701,42 +6671,6 @@ pub async fn get_latest_merged_revision(
     .await
 }
 
-/// Save a goal to the directive goal history.
-pub async fn save_directive_goal_history(
-    pool: &PgPool,
-    directive_id: Uuid,
-    goal: &str,
-) -> Result<(), sqlx::Error> {
-    sqlx::query(
-        r#"INSERT INTO directive_goal_history (directive_id, goal)
-           VALUES ($1, $2)"#,
-    )
-    .bind(directive_id)
-    .bind(goal)
-    .execute(pool)
-    .await?;
-    Ok(())
-}
-
-/// Get recent goal history for a directive (most recent first), limited to limit entries.
-pub async fn get_directive_goal_history(
-    pool: &PgPool,
-    directive_id: Uuid,
-    limit: i64,
-) -> Result<Vec<DirectiveGoalHistory>, sqlx::Error> {
-    sqlx::query_as::<_, DirectiveGoalHistory>(
-        r#"SELECT id, directive_id, goal, created_at
-           FROM directive_goal_history
-           WHERE directive_id = $1
-           ORDER BY created_at DESC
-           LIMIT $2"#,
-    )
-    .bind(directive_id)
-    .bind(limit)
-    .fetch_all(pool)
-    .await
-}
-
 /// Set a directive's status (used for start/pause/archive transitions).
 pub async fn set_directive_status(
     pool: &PgPool,
diff --git a/makima/src/orchestration/directive.rs b/makima/src/orchestration/directive.rs
index 7897c2c..384fa23 100644
--- a/makima/src/orchestration/directive.rs
+++ b/makima/src/orchestration/directive.rs
@@ -81,12 +81,14 @@ impl DirectiveOrchestrator {
             let prev_merged = repository::get_latest_merged_revision(&self.pool, directive.id)
                 .await
                 .unwrap_or(None);
+            let contract_body =
+                repository::get_active_contract_body(&self.pool, directive.id).await?;
 
             let plan = build_planning_prompt(
                 &directive,
                 &[],
                 1,
-                &[],
+                &contract_body,
                 None,
                 prev_merged.as_ref(),
             );
@@ -485,8 +487,8 @@ impl DirectiveOrchestrator {
                     repository::list_directive_steps(&self.pool, directive.id).await?;
                 let generation =
                     repository::get_directive_max_generation(&self.pool, directive.id).await? + 1;
-                let goal_history =
-                    repository::get_directive_goal_history(&self.pool, directive.id, 3).await?;
+                let contract_body =
+                    repository::get_active_contract_body(&self.pool, directive.id).await?;
 
                 // If steps are currently running (or recently completed), build a
                 // WORK IN PROGRESS summary for the planner so it doesn't re-issue
@@ -506,7 +508,7 @@ impl DirectiveOrchestrator {
                     &directive,
                     &existing_steps,
                     generation,
-                    &goal_history,
+                    &contract_body,
                     progress_summary.as_deref(),
                     prev_merged.as_ref(),
                 );
@@ -825,8 +827,12 @@ impl DirectiveOrchestrator {
                     })
                     .collect();
 
+                let contract_body = repository::get_active_contract_body(&self.pool, directive.id)
+                    .await
+                    .unwrap_or_default();
                 let prompt = build_completion_prompt(
                     &directive,
+                    &contract_body,
                     &step_tasks,
                     &step_branches,
                     &directive_branch,
@@ -1355,7 +1361,10 @@ pub async fn trigger_completion_task(
         })
         .collect();
 
-    let prompt = build_completion_prompt(&directive, &step_tasks, &step_branches, &directive_branch, base_branch);
+    let contract_body = repository::get_active_contract_body(pool, directive_id)
+        .await
+        .unwrap_or_default();
+    let prompt = build_completion_prompt(&directive, &contract_body, &step_tasks, &step_branches, &directive_branch, base_branch);
 
     let task_name = if directive.pr_url.is_some() {
         format!("Update PR: {}", directive.title)
@@ -1543,7 +1552,7 @@ fn build_planning_prompt(
     directive: &crate::db::models::Directive,
     existing_steps: &[crate::db::models::DirectiveStep],
     generation: i32,
-    goal_history: &[crate::db::models::DirectiveGoalHistory],
+    contract_body: &str,
     progress_summary: Option<&str>,
     previous_merged_revision: Option<&crate::db::models::DirectiveRevision>,
 ) -> String {
@@ -1566,7 +1575,7 @@ fn build_planning_prompt(
         prompt.push_str("PREVIOUSLY-MERGED CONTRACT (frozen content):\n");
         prompt.push_str(&prev.content);
         prompt.push_str("\n\nAMENDED CONTRACT (what the user wants now):\n");
-        prompt.push_str(&directive.goal);
+        prompt.push_str(contract_body);
         prompt.push_str(
             "\n\nIMPORTANT:\n\
              - Identify what CHANGED between the previously-merged contract and the amended one.\n\
@@ -1591,6 +1600,17 @@ fn build_planning_prompt(
         }
     }
 
+    // Always include the current contract body so the planner has the
+    // up-to-date spec, regardless of whether there are existing steps.
+    prompt.push_str("CURRENT GOAL (active contract body):\n");
+    prompt.push_str(contract_body);
+    prompt.push_str("\n\n");
+
+    // Suppress unused warning for `directive` — kept in the signature so
+    // callers don't have to plumb the contract body separately when we
+    // expand the prompt later.
+    let _ = directive;
+
     if !existing_steps.is_empty() {
         // ── RE-PLANNING header ──────────────────────────────────────
         prompt.push_str(&format!(
@@ -1599,37 +1619,6 @@ fn build_planning_prompt(
              relevant. Review each step below and act according to the instructions per status category.\n\n",
         ));
 
-        // ── Goal changes section ──────────────────────────────────
-        if !goal_history.is_empty() {
-            prompt.push_str("-- GOAL CHANGES --\n");
-            prompt.push_str("The goal has been updated. Compare the previous and current goals to understand what changed:\n\n");
-            for (i, entry) in goal_history.iter().enumerate() {
-                if i == 0 {
-                    prompt.push_str(&format!(
-                        "PREVIOUS GOAL (replaced at {}):\n{}\n\n",
-                        entry.created_at.format("%Y-%m-%d %H:%M:%S UTC"),
-                        entry.goal
-                    ));
-                } else {
-                    prompt.push_str(&format!(
-                        "OLDER GOAL (version from {}):\n{}\n\n",
-                        entry.created_at.format("%Y-%m-%d %H:%M:%S UTC"),
-                        entry.goal
-                    ));
-                }
-            }
-            prompt.push_str(&format!(
-                "CURRENT GOAL (what you must plan for):\n{}\n\n",
-                directive.goal
-            ));
-            prompt.push_str(
-                "IMPORTANT: Analyze what CHANGED between the previous goal and the current goal.\n\
-                 - If the change is minor (e.g., clarification, small addition), try to KEEP existing pending steps and only add/modify what is needed for the delta.\n\
-                 - If the change is major (e.g., completely different objective), you may need to remove most pending steps and create a fresh plan.\n\
-                 - Always preserve completed and running steps - they represent work already done.\n\n",
-            );
-        }
-
         prompt.push_str(&format!(
             "EXISTING STEPS (generation {}):\n",
             generation - 1
@@ -1763,7 +1752,18 @@ Your job:
 1. Explore the repository to understand the codebase
 2. Decompose the goal into concrete, ordered steps
 3. Each step = one task for a Claude Code instance to execute
-4. Submit ALL steps using the batch command or individual add-step commands
+4. Submit ALL steps using the batch command or individual add-step commands"#,
+        title = directive.title,
+        goal = contract_body,
+        repo_section = match &directive.repository_url {
+            Some(url) => format!("REPOSITORY: {}\n", url),
+            None => String::new(),
+        },
+    ));
+
+    // The original tail (orders, dependency rules, etc.) follows below;
+    // re-attached intact so the prompt structure is unchanged.
+    prompt.push_str(r#"
 
 For each step, define:
 - name: Short imperative title (e.g., "Add user authentication middleware")
@@ -1854,14 +1854,7 @@ When to create orders:
 Do NOT create orders for:
 - Work that should be a step in the current plan
 - Tasks that are part of the current goal
-"#,
-        title = directive.title,
-        goal = directive.goal,
-        repo_section = match &directive.repository_url {
-            Some(url) => format!("REPOSITORY: {}\n", url),
-            None => String::new(),
-        },
-    ));
+"#);
 
     prompt
 }
@@ -1869,6 +1862,7 @@ Do NOT create orders for:
 /// Build the prompt for a completion task that creates or updates a PR.
 fn build_completion_prompt(
     directive: &crate::db::models::Directive,
+    contract_body: &str,
     step_tasks: &[crate::db::repository::CompletedStepTask],
     step_branches: &[String],
     directive_branch: &str,
@@ -2050,7 +2044,7 @@ If you encounter issues you cannot resolve (e.g., persistent merge conflicts, PR
   makima directive ask "Your question" --phaseguard
 "#,
             title = directive.title,
-            goal = directive.goal,
+            goal = contract_body,
             pr_url = pr_url,
             directive_branch = directive_branch,
             base_branch = base_branch,
@@ -2058,7 +2052,7 @@ If you encounter issues you cannot resolve (e.g., persistent merge conflicts, PR
             merge_commands = merge_commands,
             pr_body = format!(
                 "## Directive\\n\\n{}\\n\\n## Steps\\n\\n{}",
-                directive.goal.replace('\n', "\\n").replace('"', "\\\""),
+                contract_body.replace('\n', "\\n").replace('"', "\\\""),
                 step_summary.replace('\n', "\\n").replace('"', "\\\""),
             ),
         )
@@ -2156,14 +2150,14 @@ If you encounter issues you cannot resolve (e.g., persistent merge conflicts, PR
   makima directive ask "Your question" --phaseguard
 "#,
             title = directive.title,
-            goal = directive.goal,
+            goal = contract_body,
             directive_branch = directive_branch,
             base_branch = base_branch,
             step_summary = step_summary,
             merge_commands = merge_commands,
             pr_body = format!(
                 "## Directive\\n\\n{}\\n\\n## Steps\\n\\n{}",
-                directive.goal.replace('\n', "\\n").replace('"', "\\\""),
+                contract_body.replace('\n', "\\n").replace('"', "\\\""),
                 step_summary.replace('\n', "\\n").replace('"', "\\\""),
             ),
         )
@@ -2316,7 +2310,7 @@ pub fn build_order_pickup_prompt(
     existing_steps: &[crate::db::models::DirectiveStep],
     orders: &[crate::db::models::Order],
     generation: i32,
-    goal_history: &[crate::db::models::DirectiveGoalHistory],
+    contract_body: &str,
 ) -> String {
     let mut prompt = String::new();
 
@@ -2326,33 +2320,13 @@ pub fn build_order_pickup_prompt(
          GOAL: {goal}\n\
          {repo_section}\n",
         title = directive.title,
-        goal = directive.goal,
+        goal = contract_body,
         repo_section = match &directive.repository_url {
             Some(url) => format!("REPOSITORY: {}\n", url),
             None => String::new(),
         },
     ));
 
-    // ── Goal history (if any) ─────────────────────────────────────
-    if !goal_history.is_empty() {
-        prompt.push_str("-- GOAL CHANGES --\n");
-        for (i, entry) in goal_history.iter().enumerate() {
-            if i == 0 {
-                prompt.push_str(&format!(
-                    "PREVIOUS GOAL (replaced at {}):\n{}\n\n",
-                    entry.created_at.format("%Y-%m-%d %H:%M:%S UTC"),
-                    entry.goal
-                ));
-            } else {
-                prompt.push_str(&format!(
-                    "OLDER GOAL (version from {}):\n{}\n\n",
-                    entry.created_at.format("%Y-%m-%d %H:%M:%S UTC"),
-                    entry.goal
-                ));
-            }
-        }
-    }
-
     // ── Orders being picked up ───────────────────────────────────
     prompt.push_str("== ORDERS AVAILABLE FOR PLANNING ==\n");
     prompt.push_str("The following open orders have been linked to this directive. \
@@ -2558,93 +2532,9 @@ Do NOT ask questions for trivial decisions — use your best judgment.
 }
 
 // =============================================================================
-// Goal-edit classification (small vs large) and interrupt helpers
+// Planner cancellation helper
 // =============================================================================
 
-/// Classification of a goal change for the goal-edit interrupt cycle.
-///
-/// When a user edits a directive's goal while a planning/replanning task is
-/// already running, we want to differentiate between:
-///   • Small edits (typo fixes, clarifications, small additions) → interrupt
-///     the current planner with a `SendMessage` so it can adjust its in-flight
-///     plan rather than throwing away its work.
-///   • Large edits (substantial rewrites, completely different objective) →
-///     fall back to the existing replan path (cancel + spawn a new planner).
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum GoalChangeKind {
-    /// Small change — interrupt the running planner with the diff.
-    Small,
-    /// Large change — proceed with full replan.
-    Large,
-}
-
-/// Heuristic: classify a goal edit as small or large.
-///
-/// Rules (POC heuristic, kept deliberately simple):
-///  1. Empty old goal or empty new goal → Large (treat as a fresh start).
-///  2. If one goal is a prefix of the other → Small (pure addition / truncation).
-///  3. If the absolute length difference relative to the longer goal is < 0.3,
-///     classify as Small. Otherwise Large.
-pub fn classify_goal_change(old: &str, new: &str) -> GoalChangeKind {
-    let old = old.trim();
-    let new = new.trim();
-
-    if old.is_empty() || new.is_empty() {
-        return GoalChangeKind::Large;
-    }
-
-    if old == new {
-        // No content change — treat as small (no-op for the planner).
-        return GoalChangeKind::Small;
-    }
-
-    // Pure prefix changes (added a sentence at the end, or removed a trailing
-    // clause) are almost always small.
-    if old.starts_with(new) || new.starts_with(old) {
-        return GoalChangeKind::Small;
-    }
-
-    let old_len = old.chars().count();
-    let new_len = new.chars().count();
-    let longer = old_len.max(new_len) as f64;
-    let diff = (old_len as i64 - new_len as i64).unsigned_abs() as f64;
-    if longer == 0.0 {
-        return GoalChangeKind::Large;
-    }
-    let length_ratio = diff / longer;
-
-    if length_ratio < 0.3 {
-        GoalChangeKind::Small
-    } else {
-        GoalChangeKind::Large
-    }
-}
-
-/// Format the goal-edit interrupt message sent to a running planner task
-/// when the user edits the directive goal mid-flight.
-pub fn build_goal_edit_interrupt_message(old_goal: &str, new_goal: &str) -> String {
-    format!(
-        "GOAL_UPDATED: The user has edited the directive goal. Summary of changes follows. \
-         Adjust your current plan in-flight rather than starting over.\n\
-         --- OLD GOAL ---\n\
-         {old}\n\
-         --- NEW GOAL ---\n\
-         {new}\n",
-        old = old_goal,
-        new = new_goal,
-    )
-}
-
-/// Result of attempting to send a goal-edit interrupt to a running planner.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum GoalEditInterruptResult {
-    /// A `SendMessage` daemon command was dispatched to the running planner.
-    Sent,
-    /// No suitable planner task was running, or the change was classified as
-    /// large — caller should fall through to the regular replanning path.
-    Skipped,
-}
-
 /// Best-effort cancellation of a directive's currently-running orchestrator
 /// (planner) task. Used by the goal-update path: when we are about to clear
 /// `orchestrator_task_id` from the directive, the still-running task would
@@ -2727,160 +2617,5 @@ pub async fn try_cancel_running_planner(
     Ok(true)
 }
 
-/// Attempt to interrupt a directive's currently-running planner with a goal
-/// edit summary instead of replanning from scratch.
-///
-/// Returns `Ok(GoalEditInterruptResult::Sent)` when a `SendMessage` was
-/// dispatched. Returns `Ok(GoalEditInterruptResult::Skipped)` when the change
-/// was large, no orchestrator task exists, the task has already finished, or
-/// no daemon is currently assigned.
-///
-/// This function is best-effort: errors talking to the daemon are logged and
-/// translated into `Skipped` so the caller can fall through to the normal
-/// replan path.
-pub async fn try_interrupt_planner_with_goal_edit(
-    pool: &PgPool,
-    state: &SharedState,
-    directive_id: Uuid,
-    old_goal: &str,
-    new_goal: &str,
-) -> Result<GoalEditInterruptResult, anyhow::Error> {
-    // Only fire if the change classifies as small.
-    if classify_goal_change(old_goal, new_goal) != GoalChangeKind::Small {
-        tracing::debug!(
-            directive_id = %directive_id,
-            "Goal change classified as large — skipping planner interrupt"
-        );
-        return Ok(GoalEditInterruptResult::Skipped);
-    }
-
-    // Look up the directive's current orchestrator task (planner).
-    let directive = match repository::get_directive(pool, directive_id).await? {
-        Some(d) => d,
-        None => return Ok(GoalEditInterruptResult::Skipped),
-    };
-    let Some(orchestrator_task_id) = directive.orchestrator_task_id else {
-        return Ok(GoalEditInterruptResult::Skipped);
-    };
-
-    // Fetch the planner task to confirm it's still queued/running.
-    let task = match repository::get_task(pool, orchestrator_task_id).await? {
-        Some(t) => t,
-        None => return Ok(GoalEditInterruptResult::Skipped),
-    };
-
-    let interruptible = matches!(
-        task.status.as_str(),
-        "queued" | "pending" | "starting" | "running"
-    );
-    if !interruptible {
-        tracing::debug!(
-            directive_id = %directive_id,
-            task_id = %orchestrator_task_id,
-            task_status = %task.status,
-            "Planner task is not in an interruptible state — skipping interrupt"
-        );
-        return Ok(GoalEditInterruptResult::Skipped);
-    }
-
-    let Some(daemon_id) = task.daemon_id else {
-        tracing::debug!(
-            directive_id = %directive_id,
-            task_id = %orchestrator_task_id,
-            "Planner task has no assigned daemon — skipping interrupt"
-        );
-        return Ok(GoalEditInterruptResult::Skipped);
-    };
-
-    let message = build_goal_edit_interrupt_message(old_goal, new_goal);
-    let command = DaemonCommand::SendMessage {
-        task_id: orchestrator_task_id,
-        message,
-    };
-
-    match state.send_daemon_command(daemon_id, command).await {
-        Ok(()) => {
-            tracing::info!(
-                directive_id = %directive_id,
-                task_id = %orchestrator_task_id,
-                daemon_id = %daemon_id,
-                "Sent goal-edit interrupt to running planner"
-            );
-            Ok(GoalEditInterruptResult::Sent)
-        }
-        Err(e) => {
-            tracing::warn!(
-                directive_id = %directive_id,
-                task_id = %orchestrator_task_id,
-                daemon_id = %daemon_id,
-                error = %e,
-                "Failed to send goal-edit interrupt — falling back to replan"
-            );
-            Ok(GoalEditInterruptResult::Skipped)
-        }
-    }
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn classifier_identical_goal_is_small() {
-        assert_eq!(
-            classify_goal_change("Build a todo app", "Build a todo app"),
-            GoalChangeKind::Small
-        );
-    }
-
-    #[test]
-    fn classifier_pure_addition_is_small() {
-        let old = "Build a todo app";
-        let new = "Build a todo app with authentication";
-        assert_eq!(classify_goal_change(old, new), GoalChangeKind::Small);
-    }
-
-    #[test]
-    fn classifier_pure_truncation_is_small() {
-        let old = "Build a todo app with authentication and tests";
-        let new = "Build a todo app";
-        assert_eq!(classify_goal_change(old, new), GoalChangeKind::Small);
-    }
-
-    #[test]
-    fn classifier_typo_fix_is_small() {
-        // Same length, single character diff — well below 0.3 length ratio.
-        let old = "Build a todo aap with authentication and tests today";
-        let new = "Build a todo app with authentication and tests today";
-        assert_eq!(classify_goal_change(old, new), GoalChangeKind::Small);
-    }
-
-    #[test]
-    fn classifier_completely_different_is_large() {
-        // Wildly different lengths and content.
-        let old = "Build a todo app";
-        let new = "Migrate the entire backend to Rust, port the frontend to Svelte, \
-                   and add a new realtime collaboration feature with operational transforms";
-        assert_eq!(classify_goal_change(old, new), GoalChangeKind::Large);
-    }
-
-    #[test]
-    fn classifier_empty_goals_are_large() {
-        assert_eq!(classify_goal_change("", "Anything"), GoalChangeKind::Large);
-        assert_eq!(classify_goal_change("Anything", ""), GoalChangeKind::Large);
-    }
-
-    #[test]
-    fn interrupt_message_contains_old_and_new() {
-        let msg = build_goal_edit_interrupt_message("OLD", "NEW");
-        assert!(msg.contains("GOAL_UPDATED"));
-        assert!(msg.contains("OLD"));
-        assert!(msg.contains("NEW"));
-        assert!(msg.contains("--- OLD GOAL ---"));
-        assert!(msg.contains("--- NEW GOAL ---"));
-    }
-}
+// (Goal-edit classification + interrupt helpers were tied to directive.goal,
+// which has been dropped. Their unit tests went with them.)
diff --git a/makima/src/server/handlers/directives.rs b/makima/src/server/handlers/directives.rs
index 7b13f1c..6d99179 100644
--- a/makima/src/server/handlers/directives.rs
+++ b/makima/src/server/handlers/directives.rs
@@ -13,7 +13,7 @@ use crate::db::models::{
     CreateDirectiveStepRequest, Directive, DirectiveListResponse,
     DirectiveRevision, DirectiveStep, DirectiveWithSteps, PickUpOrdersResponse,
     Task,
-    UpdateDirectiveRequest, UpdateDirectiveStepRequest, UpdateGoalRequest,
+    UpdateDirectiveRequest, UpdateDirectiveStepRequest,
     CreateDirectiveOrderGroupRequest, DirectiveOrderGroup,
     DirectiveOrderGroupListResponse, UpdateDirectiveOrderGroupRequest,
     OrderListResponse,
@@ -22,9 +22,8 @@ use serde::Serialize;
 use utoipa::ToSchema;
 use crate::db::repository;
 use crate::orchestration::directive::{
-    build_cleanup_prompt, build_order_pickup_prompt, classify_goal_change,
-    try_cancel_running_planner, try_interrupt_planner_with_goal_edit,
-    GoalChangeKind, GoalEditInterruptResult,
+    build_cleanup_prompt, build_order_pickup_prompt,
+    try_cancel_running_planner,
 };
 use crate::server::auth::Authenticated;
 use crate::server::messages::ApiError;
@@ -200,15 +199,19 @@ pub async fn update_directive(
     match repository::update_directive_for_owner(pool, auth.owner_id, id, req).await {
         Ok(Some(directive)) => {
             // Detect "PR was just raised" — pr_url went from None to Some.
-            // Snapshot the current goal as a revision tied to this PR.
-            // Best-effort: a snapshot failure should not fail the update,
-            // because the directive's pr_url has already been written.
+            // Snapshot the active contract's body as a revision tied to
+            // this PR. Best-effort: a snapshot failure should not fail
+            // the update, because the directive's pr_url has already
+            // been written.
             if before_pr_url.is_none() {
                 if let Some(ref new_pr_url) = directive.pr_url {
+                    let snapshot_body = repository::get_active_contract_body(pool, directive.id)
+                        .await
+                        .unwrap_or_default();
                     if let Err(e) = repository::create_directive_revision(
                         pool,
                         directive.id,
-                        &directive.goal,
+                        &snapshot_body,
                         new_pr_url,
                         directive.pr_branch.as_deref(),
                     )
@@ -859,152 +862,10 @@ async fn step_status_change(
     }
 }
 
-/// Update a directive's goal (triggers re-planning).
-#[utoipa::path(
-    put,
-    path = "/api/v1/directives/{id}/goal",
-    params(("id" = Uuid, Path, description = "Directive ID")),
-    request_body = UpdateGoalRequest,
-    responses(
-        (status = 200, description = "Goal updated", body = Directive),
-        (status = 404, description = "Not found", body = ApiError),
-        (status = 503, description = "Database not configured", body = ApiError),
-    ),
-    security(("bearer_auth" = []), ("api_key" = [])),
-    tag = "Directives"
-)]
-pub async fn update_goal(
-    State(state): State<SharedState>,
-    Authenticated(auth): Authenticated,
-    Path(id): Path<Uuid>,
-    Json(req): Json<UpdateGoalRequest>,
-) -> impl IntoResponse {
-    let Some(ref pool) = state.db_pool else {
-        return (
-            StatusCode::SERVICE_UNAVAILABLE,
-            Json(ApiError::new("DB_UNAVAILABLE", "Database not configured")),
-        )
-            .into_response();
-    };
-
-    // Fetch the current directive so we can:
-    //   1. Save the old goal to history (best-effort).
-    //   2. Decide whether to fire a goal-edit interrupt at a running planner.
-    let current = match repository::get_directive_for_owner(pool, auth.owner_id, id).await {
-        Ok(Some(d)) => Some(d),
-        Ok(None) => None,
-        Err(e) => {
-            tracing::warn!(
-                directive_id = %id,
-                error = %e,
-                "Failed to fetch current directive for goal history — continuing with goal update"
-            );
-            None
-        }
-    };
-
-    // Save old goal to history before overwriting (best-effort).
-    if let Some(ref current) = current {
-        if let Err(e) = repository::save_directive_goal_history(pool, id, &current.goal).await {
-            tracing::warn!(
-                directive_id = %id,
-                error = %e,
-                "Failed to save goal history before update — continuing with goal update"
-            );
-        }
-    }
-
-    // Goal-edit interrupt cycle: if a planner task is currently running for
-    // this directive AND the goal change classifies as 'small', interrupt the
-    // running planner via SendMessage instead of clearing it (which would
-    // trigger a fresh replan on the next orchestrator tick).
-    let mut interrupted = false;
-    if let Some(ref current) = current {
-        if current.orchestrator_task_id.is_some()
-            && classify_goal_change(&current.goal, &req.goal) == GoalChangeKind::Small
-        {
-            match try_interrupt_planner_with_goal_edit(
-                pool,
-                &state,
-                id,
-                &current.goal,
-                &req.goal,
-            )
-            .await
-            {
-                Ok(GoalEditInterruptResult::Sent) => {
-                    interrupted = true;
-                }
-                Ok(GoalEditInterruptResult::Skipped) => {}
-                Err(e) => {
-                    tracing::warn!(
-                        directive_id = %id,
-                        error = %e,
-                        "Goal-edit interrupt attempt errored — falling back to replan"
-                    );
-                }
-            }
-        }
-    }
-
-    // If we successfully interrupted a running planner, persist the new goal
-    // WITHOUT clearing the orchestrator task — the planner will react to the
-    // SendMessage and adjust in-flight. Otherwise, fall through to the normal
-    // path which clears orchestrator_task_id and lets phase_replanning kick
-    // in on the next tick.
-    //
-    // CRITICAL: when going down the "clear" path, we must also CANCEL the
-    // running planner. Otherwise the orphaned task keeps producing add-step
-    // calls based on the old goal, racing the freshly-spawned replanner.
-    if !interrupted {
-        if let Some(ref current) = current {
-            if let Some(orch_task_id) = current.orchestrator_task_id {
-                if let Err(e) = try_cancel_running_planner(pool, &state, id, orch_task_id).await {
-                    tracing::warn!(
-                        directive_id = %id,
-                        task_id = %orch_task_id,
-                        error = %e,
-                        "Failed to cancel orphaned planner — proceeding with clear anyway"
-                    );
-                }
-            }
-        }
-    }
-
-    let update_result = if interrupted {
-        repository::update_directive_goal_keep_orchestrator(pool, auth.owner_id, id, &req.goal)
-            .await
-    } else {
-        repository::update_directive_goal(pool, auth.owner_id, id, &req.goal).await
-    };
-
-    let response = match update_result {
-        Ok(Some(directive)) => Json(directive).into_response(),
-        Ok(None) => {
-            return (
-                StatusCode::NOT_FOUND,
-                Json(ApiError::new("NOT_FOUND", "Directive not found")),
-            )
-                .into_response();
-        }
-        Err(e) => {
-            tracing::error!("Failed to update goal: {}", e);
-            return (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(ApiError::new("UPDATE_FAILED", &e.to_string())),
-            )
-                .into_response();
-        }
-    };
-
-    // Nudge the directive reconciler so the user does not wait up to 15s for
-    // the next interval tick before the new planner is spawned (clear path) or
-    // the small-edit interrupt is consumed (keep path). Best-effort: if the
-    // channel is full or closed we just rely on the normal interval.
-    state.kick_directive_reconciler();
-
-    response
-}
+// (Goal updates now flow through the contracts API. The directive's
+// orchestrator reads the active contract's body when it spawns or
+// replans — see repository::get_active_contract_body and the
+// orchestration module.)
 
 // =============================================================================
 // Task Cleanup
@@ -1404,16 +1265,13 @@ pub async fn pick_up_orders(
             }
         };
 
-    let goal_history = match repository::get_directive_goal_history(pool, id, 3).await {
-        Ok(h) => h,
-        Err(e) => {
-            tracing::warn!("Failed to get goal history: {}", e);
-            vec![]
-        }
-    };
-
-    // Build the specialized planning prompt
-    let plan = build_order_pickup_prompt(&directive, &steps, &orders, generation, &goal_history);
+    // Build the specialized planning prompt. The orchestrator reads the
+    // active contract's body itself when it picks up the task; we just
+    // pass the directive shape + steps + orders + generation here.
+    let contract_body = repository::get_active_contract_body(pool, id)
+        .await
+        .unwrap_or_default();
+    let plan = build_order_pickup_prompt(&directive, &steps, &orders, generation, &contract_body);
 
     // Link orders to the directive
     if let Err(e) =
@@ -1984,16 +1842,13 @@ pub async fn pick_up_dog_orders(
             }
         };
 
-    let goal_history = match repository::get_directive_goal_history(pool, id, 3).await {
-        Ok(h) => h,
-        Err(e) => {
-            tracing::warn!("Failed to get goal history: {}", e);
-            vec![]
-        }
-    };
-
-    // Build the specialized planning prompt
-    let plan = build_order_pickup_prompt(&directive, &steps, &orders, generation, &goal_history);
+    // Build the specialized planning prompt. The orchestrator reads the
+    // active contract's body itself when it picks up the task; we just
+    // pass the directive shape + steps + orders + generation here.
+    let contract_body = repository::get_active_contract_body(pool, id)
+        .await
+        .unwrap_or_default();
+    let plan = build_order_pickup_prompt(&directive, &steps, &orders, generation, &contract_body);
 
     // Link orders to the directive
     if let Err(e) =
diff --git a/makima/src/server/mod.rs b/makima/src/server/mod.rs
index a3a1886..604caea 100644
--- a/makima/src/server/mod.rs
+++ b/makima/src/server/mod.rs
@@ -191,7 +191,6 @@ pub fn make_router(state: SharedState) -> Router {
         .route("/directives/{id}/steps/{step_id}/complete", post(directives::complete_step))
         .route("/directives/{id}/steps/{step_id}/fail", post(directives::fail_step))
         .route("/directives/{id}/steps/{step_id}/skip", post(directives::skip_step))
-        .route("/directives/{id}/goal", put(directives::update_goal))
         .route("/directives/{id}/revisions", get(directives::list_directive_revisions))
         .route("/directives/{id}/new-draft", post(directives::new_directive_draft))
         .route(
diff --git a/makima/src/server/openapi.rs b/makima/src/server/openapi.rs
index 184d12a..437285f 100644
--- a/makima/src/server/openapi.rs
+++ b/makima/src/server/openapi.rs
@@ -25,7 +25,7 @@ use crate::db::models::{
     Task,
     TaskEventListResponse, TaskListResponse, TaskSummary, TaskWithSubtasks, TranscriptEntry,
     UpdateContractRequest, UpdateDirectiveRequest, UpdateDirectiveStepRequest,
-    UpdateFileRequest, UpdateGoalRequest, UpdateOrderRequest, UpdateTaskRequest,
+    UpdateFileRequest, UpdateOrderRequest, UpdateTaskRequest,
 };
 use crate::server::auth::{
     ApiKey, ApiKeyInfoResponse, CreateApiKeyRequest, CreateApiKeyResponse,
@@ -109,7 +109,6 @@ use crate::server::messages::{ApiError, AudioEncoding, StartMessage, StopMessage
         directives::complete_step,
         directives::fail_step,
         directives::skip_step,
-        directives::update_goal,
         directives::list_directive_revisions,
         directives::new_directive_draft,
         directives::create_directive_task,
@@ -227,7 +226,6 @@ use crate::server::messages::{ApiError, AudioEncoding, StartMessage, StopMessage
             crate::server::handlers::directives::CreateDirectiveTaskRequest,
             CreateDirectiveRequest,
             UpdateDirectiveRequest,
-            UpdateGoalRequest,
             CreateDirectiveStepRequest,
             UpdateDirectiveStepRequest,
             CleanupResponse,