Add directive-first chain system redesign

Redesigns the chain system with a directive-first architecture where
Directive is the top-level entity (the "why/what") and Chains are
generated execution plans (the "how") that can be dynamically modified.

Backend:
- Add database migration for directive system tables
- Add Directive, DirectiveChain, ChainStep, DirectiveEvent models
- Add DirectiveVerifier and DirectiveApproval models
- Add orchestration module with engine, planner, and verifier
- Add comprehensive API handlers for directives
- Add daemon CLI commands for directive management
- Add directive skill documentation
- Integrate contract completion with directive engine
- Add SSE endpoint for real-time directive events

Frontend:
- Add directives route with split-view layout
- Add 6-tab detail view (Overview, Chain, Events, Evaluations, Approvals, Verifiers)
- Add React Flow DAG visualization for chain steps
- Add SSE subscription hook for real-time event updates
- Add useDirectives and useDirectiveEventSubscription hooks
- Add directive types and API functions

Fixes:
- Fix test failures in ws/protocol, task_output, completion_gate, patch
- Fix word boundary matching in looks_like_task()
- Fix parse_last() to find actual last completion gate
- Fix create_export_patch when merge-base equals HEAD
- Clean up clippy warnings in new code

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

2 files changed, 1295 insertions, 2303 deletions

diff --git a/makima/src/db/models.rs b/makima/src/db/models.rs
index e861f1d..3a96165 100644
--- a/makima/src/db/models.rs
+++ b/makima/src/db/models.rs
@@ -1446,16 +1446,16 @@ pub struct Contract {
     /// Use `get_phase_config()` to get the parsed PhaseConfig.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub phase_config: Option<serde_json::Value>,
-    /// Chain ID if this contract is part of a chain (DAG of contracts)
+    /// Directive ID if this contract is part of a directive's chain
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub chain_id: Option<Uuid>,
-    /// Reference to chain spawned by this directive contract
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub spawned_chain_id: Option<Uuid>,
-    /// Whether this contract is a chain directive orchestrator
+    pub directive_id: Option<Uuid>,
+    /// Whether this contract is a directive orchestrator
     #[serde(default)]
     #[sqlx(default)]
-    pub is_chain_directive: bool,
+    pub is_directive_orchestrator: bool,
+    /// Reference to directive spawned by this orchestrator contract
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub spawned_directive_id: Option<Uuid>,
     pub version: i32,
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
@@ -2596,914 +2596,648 @@ pub struct HeartbeatHistoryQuery {
 }
 
 // =============================================================================
-// Chains (DAG of contracts for multi-contract orchestration)
+// Directives (Goal-driven orchestration with chains of steps)
 // =============================================================================
 
-/// Chain status determines the overall state of the chain
+/// Directive status
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "lowercase")]
-pub enum ChainStatus {
-    /// Chain is actively running
+#[serde(rename_all = "snake_case")]
+pub enum DirectiveStatus {
+    Draft,
+    Planning,
     Active,
-    /// All contracts completed successfully
+    Paused,
     Completed,
-    /// Chain was manually archived
     Archived,
+    Failed,
 }
 
-impl Default for ChainStatus {
+impl Default for DirectiveStatus {
     fn default() -> Self {
-        ChainStatus::Active
+        DirectiveStatus::Draft
     }
 }
 
-impl std::fmt::Display for ChainStatus {
+impl std::fmt::Display for DirectiveStatus {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ChainStatus::Active => write!(f, "active"),
-            ChainStatus::Completed => write!(f, "completed"),
-            ChainStatus::Archived => write!(f, "archived"),
+            DirectiveStatus::Draft => write!(f, "draft"),
+            DirectiveStatus::Planning => write!(f, "planning"),
+            DirectiveStatus::Active => write!(f, "active"),
+            DirectiveStatus::Paused => write!(f, "paused"),
+            DirectiveStatus::Completed => write!(f, "completed"),
+            DirectiveStatus::Archived => write!(f, "archived"),
+            DirectiveStatus::Failed => write!(f, "failed"),
         }
     }
 }
 
-impl std::str::FromStr for ChainStatus {
+impl std::str::FromStr for DirectiveStatus {
     type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_lowercase().as_str() {
-            "active" => Ok(ChainStatus::Active),
-            "completed" => Ok(ChainStatus::Completed),
-            "archived" => Ok(ChainStatus::Archived),
-            _ => Err(format!("Invalid chain status: {}", s)),
+            "draft" => Ok(DirectiveStatus::Draft),
+            "planning" => Ok(DirectiveStatus::Planning),
+            "active" => Ok(DirectiveStatus::Active),
+            "paused" => Ok(DirectiveStatus::Paused),
+            "completed" => Ok(DirectiveStatus::Completed),
+            "archived" => Ok(DirectiveStatus::Archived),
+            "failed" => Ok(DirectiveStatus::Failed),
+            _ => Err(format!("Invalid directive status: {}", s)),
         }
     }
 }
 
-/// Chain - a directed acyclic graph (DAG) of contracts
-/// Fits Makima's control theme - she controls through invisible chains
+/// Directive - the top-level goal-driven orchestration entity
 #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct Chain {
+pub struct Directive {
     pub id: Uuid,
     pub owner_id: Uuid,
-    pub name: String,
-    pub description: Option<String>,
+    pub title: String,
+    pub goal: String,
+    /// Structured requirements: [{ id, title, description, priority, category }]
+    #[sqlx(json)]
+    pub requirements: serde_json::Value,
+    /// Acceptance criteria: [{ id, requirementIds, description, testable, verificationMethod }]
+    #[sqlx(json)]
+    pub acceptance_criteria: serde_json::Value,
+    /// Constraints: [{ id, type, description, impact }]
+    #[sqlx(json)]
+    pub constraints: serde_json::Value,
+    /// External dependencies: [{ id, name, type, status, requiredBy }]
+    #[sqlx(json)]
+    pub external_dependencies: serde_json::Value,
     pub status: String,
-    /// Whether loop mode is enabled for iterative execution
-    #[serde(default)]
-    pub loop_enabled: bool,
-    /// Maximum loop iterations (default: 10)
-    pub loop_max_iterations: Option<i32>,
-    /// Current loop iteration count
-    pub loop_current_iteration: Option<i32>,
-    /// Progress check prompt/criteria for evaluating loop completion
-    pub loop_progress_check: Option<String>,
-    /// Reference to the directive contract that created/orchestrates this chain
-    pub directive_contract_id: Option<Uuid>,
-    /// The directive document text (formal specification)
-    pub directive_document: Option<String>,
-    /// Whether LLM evaluation is enabled after contract completion
-    #[serde(default = "default_evaluation_enabled")]
-    #[sqlx(default)]
-    pub evaluation_enabled: bool,
-    /// Default pass threshold for evaluations (0.0-1.0)
-    pub default_pass_threshold: Option<f64>,
-    /// Default max retry attempts for evaluations
-    pub default_max_retries: Option<i32>,
-    /// Version for optimistic locking
+    pub autonomy_level: String,
+    pub confidence_threshold_green: f64,
+    pub confidence_threshold_yellow: f64,
+    pub max_total_cost_usd: Option<f64>,
+    pub max_wall_time_minutes: Option<i32>,
+    pub max_rework_cycles: Option<i32>,
+    pub max_chain_regenerations: Option<i32>,
+    pub repository_url: Option<String>,
+    pub local_path: Option<String>,
+    pub base_branch: Option<String>,
+    pub orchestrator_contract_id: Option<Uuid>,
+    pub current_chain_id: Option<Uuid>,
+    pub chain_generation_count: i32,
+    pub total_cost_usd: f64,
+    pub started_at: Option<DateTime<Utc>>,
+    pub completed_at: Option<DateTime<Utc>>,
     pub version: i32,
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
 }
 
-fn default_evaluation_enabled() -> bool {
-    true
+impl Directive {
+    /// Parse status string to DirectiveStatus enum
+    pub fn status_enum(&self) -> Result<DirectiveStatus, String> {
+        self.status.parse()
+    }
 }
 
-/// Chain repository record from the database
+/// Directive chain - a generated execution plan (DAG) for a directive
 #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainRepository {
+pub struct DirectiveChain {
     pub id: Uuid,
-    pub chain_id: Uuid,
+    pub directive_id: Uuid,
+    pub generation: i32,
     pub name: String,
-    pub repository_url: Option<String>,
-    pub local_path: Option<String>,
-    pub source_type: String,
+    pub description: Option<String>,
+    pub rationale: Option<String>,
+    pub planning_model: Option<String>,
     pub status: String,
-    pub is_primary: bool,
+    pub total_steps: i32,
+    pub completed_steps: i32,
+    pub failed_steps: i32,
+    pub current_confidence: Option<f64>,
+    pub started_at: Option<DateTime<Utc>>,
+    pub completed_at: Option<DateTime<Utc>>,
+    pub version: i32,
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
 }
 
-impl ChainRepository {
-    /// Parse source_type string to RepositorySourceType enum
-    pub fn source_type_enum(&self) -> Result<RepositorySourceType, String> {
-        self.source_type.parse()
+/// Chain step status
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum StepStatus {
+    Pending,
+    Ready,
+    Running,
+    Evaluating,
+    Passed,
+    Failed,
+    Rework,
+    Skipped,
+    Blocked,
+}
+
+impl Default for StepStatus {
+    fn default() -> Self {
+        StepStatus::Pending
     }
+}
 
-    /// Parse status string to RepositoryStatus enum
-    pub fn status_enum(&self) -> Result<RepositoryStatus, String> {
-        self.status.parse()
+impl std::fmt::Display for StepStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StepStatus::Pending => write!(f, "pending"),
+            StepStatus::Ready => write!(f, "ready"),
+            StepStatus::Running => write!(f, "running"),
+            StepStatus::Evaluating => write!(f, "evaluating"),
+            StepStatus::Passed => write!(f, "passed"),
+            StepStatus::Failed => write!(f, "failed"),
+            StepStatus::Rework => write!(f, "rework"),
+            StepStatus::Skipped => write!(f, "skipped"),
+            StepStatus::Blocked => write!(f, "blocked"),
+        }
     }
 }
 
-impl Chain {
-    /// Parse status string to ChainStatus enum
-    pub fn status_enum(&self) -> Result<ChainStatus, String> {
-        self.status.parse()
+impl std::str::FromStr for StepStatus {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "pending" => Ok(StepStatus::Pending),
+            "ready" => Ok(StepStatus::Ready),
+            "running" => Ok(StepStatus::Running),
+            "evaluating" => Ok(StepStatus::Evaluating),
+            "passed" => Ok(StepStatus::Passed),
+            "failed" => Ok(StepStatus::Failed),
+            "rework" => Ok(StepStatus::Rework),
+            "skipped" => Ok(StepStatus::Skipped),
+            "blocked" => Ok(StepStatus::Blocked),
+            _ => Err(format!("Invalid step status: {}", s)),
+        }
     }
 }
 
-/// Chain contract link - links contracts to chains with DAG dependency info
+/// Chain step - a node in the DAG execution plan
 #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainContract {
+pub struct ChainStep {
     pub id: Uuid,
     pub chain_id: Uuid,
-    pub contract_id: Uuid,
-    /// Contract IDs this contract depends on (DAG edges)
+    pub name: String,
+    pub description: Option<String>,
+    pub step_type: String,
+    pub contract_type: String,
+    pub initial_phase: Option<String>,
+    pub task_plan: Option<String>,
     #[sqlx(default)]
-    pub depends_on: Vec<Uuid>,
-    /// Order for display/processing (topological sort order)
-    pub order_index: i32,
-    /// X position for GUI editor
-    pub editor_x: Option<f64>,
-    /// Y position for GUI editor
-    pub editor_y: Option<f64>,
-    /// Evaluation status: pending, evaluating, passed, failed, rework, escalated
-    #[serde(default = "default_evaluation_status")]
+    pub phases: Vec<String>,
     #[sqlx(default)]
-    pub evaluation_status: String,
-    /// Number of evaluation retry attempts
-    #[serde(default)]
+    pub depends_on: Vec<Uuid>,
+    pub parallel_group: Option<String>,
     #[sqlx(default)]
-    pub evaluation_retry_count: i32,
-    /// Maximum evaluation retry attempts (default: 3)
-    #[serde(default = "default_max_evaluation_retries")]
+    pub requirement_ids: Vec<String>,
     #[sqlx(default)]
-    pub max_evaluation_retries: i32,
-    /// Reference to the last evaluation result
+    pub acceptance_criteria_ids: Vec<String>,
+    #[sqlx(json)]
+    #[serde(default)]
+    pub verifier_config: serde_json::Value,
+    pub status: String,
+    pub contract_id: Option<Uuid>,
+    pub supervisor_task_id: Option<Uuid>,
+    pub confidence_score: Option<f64>,
+    pub confidence_level: Option<String>,
+    pub evaluation_count: i32,
+    pub rework_count: i32,
     pub last_evaluation_id: Option<Uuid>,
-    /// Rework feedback/instructions from failed evaluation
-    pub rework_feedback: Option<String>,
-    /// When rework was started
-    pub rework_started_at: Option<DateTime<Utc>>,
-    /// When contract originally completed (before rework)
-    pub original_completion_at: Option<DateTime<Utc>>,
+    pub editor_x: Option<f64>,
+    pub editor_y: Option<f64>,
+    pub order_index: i32,
+    pub started_at: Option<DateTime<Utc>>,
+    pub completed_at: Option<DateTime<Utc>>,
     pub created_at: DateTime<Utc>,
 }
 
-fn default_evaluation_status() -> String {
-    "pending".to_string()
+impl ChainStep {
+    /// Parse status string to StepStatus enum
+    pub fn status_enum(&self) -> Result<StepStatus, String> {
+        self.status.parse()
+    }
 }
 
-fn default_max_evaluation_retries() -> i32 {
-    3
+/// Confidence level (traffic light)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum ConfidenceLevel {
+    Green,
+    Yellow,
+    Red,
+}
+
+impl ConfidenceLevel {
+    pub fn from_score(score: f64, green_threshold: f64, yellow_threshold: f64) -> Self {
+        if score >= green_threshold {
+            Self::Green
+        } else if score >= yellow_threshold {
+            Self::Yellow
+        } else {
+            Self::Red
+        }
+    }
 }
 
-/// Chain event for audit trail
+impl std::fmt::Display for ConfidenceLevel {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ConfidenceLevel::Green => write!(f, "green"),
+            ConfidenceLevel::Yellow => write!(f, "yellow"),
+            ConfidenceLevel::Red => write!(f, "red"),
+        }
+    }
+}
+
+/// Directive evaluation - composite programmatic + LLM evaluation result
 #[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainEvent {
+pub struct DirectiveEvaluation {
     pub id: Uuid,
-    pub chain_id: Uuid,
-    pub event_type: String,
+    pub directive_id: Uuid,
+    pub chain_id: Option<Uuid>,
+    pub step_id: Option<Uuid>,
     pub contract_id: Option<Uuid>,
+    pub evaluation_type: String,
+    pub evaluation_number: i32,
+    pub evaluator: Option<String>,
+    pub passed: bool,
+    pub overall_score: Option<f64>,
+    pub confidence_level: Option<String>,
     #[sqlx(json)]
-    pub event_data: Option<serde_json::Value>,
+    #[serde(default)]
+    pub programmatic_results: serde_json::Value,
+    #[sqlx(json)]
+    #[serde(default)]
+    pub llm_results: serde_json::Value,
+    #[sqlx(json)]
+    #[serde(default)]
+    pub criteria_results: serde_json::Value,
+    pub summary_feedback: String,
+    pub rework_instructions: Option<String>,
+    #[sqlx(json)]
+    pub directive_snapshot: Option<serde_json::Value>,
+    #[sqlx(json)]
+    pub deliverables_snapshot: Option<serde_json::Value>,
+    pub started_at: DateTime<Utc>,
+    pub completed_at: Option<DateTime<Utc>>,
     pub created_at: DateTime<Utc>,
 }
 
-/// Summary of a chain for list views
-#[derive(Debug, Clone, FromRow, Serialize, ToSchema)]
+/// Directive event - audit stream entry
+#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainSummary {
+pub struct DirectiveEvent {
     pub id: Uuid,
-    pub name: String,
-    pub description: Option<String>,
-    pub status: String,
-    pub loop_enabled: bool,
-    pub loop_current_iteration: Option<i32>,
-    pub contract_count: i64,
-    pub completed_count: i64,
-    pub version: i32,
+    pub directive_id: Uuid,
+    pub chain_id: Option<Uuid>,
+    pub step_id: Option<Uuid>,
+    pub event_type: String,
+    pub severity: String,
+    #[sqlx(json)]
+    pub event_data: Option<serde_json::Value>,
+    pub actor_type: String,
+    pub actor_id: Option<Uuid>,
     pub created_at: DateTime<Utc>,
 }
 
-/// Chain with contracts for detail view
-#[derive(Debug, Serialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainWithContracts {
-    #[serde(flatten)]
-    pub chain: Chain,
-    pub contracts: Vec<ChainContractDetail>,
-    pub repositories: Vec<ChainRepository>,
-}
-
-/// Contract detail within a chain (includes contract info + chain link info)
-#[derive(Debug, Clone, FromRow, Serialize, ToSchema)]
+/// Directive verifier - pluggable verification configuration
+#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainContractDetail {
-    pub chain_contract_id: Uuid,
-    pub contract_id: Uuid,
-    pub contract_name: String,
-    pub contract_status: String,
-    pub contract_phase: String,
-    #[sqlx(default)]
-    pub depends_on: Vec<Uuid>,
-    pub order_index: i32,
-    pub editor_x: Option<f64>,
-    pub editor_y: Option<f64>,
-    /// Evaluation status: pending, passed, failed, rework
-    #[sqlx(default)]
-    pub evaluation_status: Option<String>,
-    /// Number of evaluation retries
-    #[sqlx(default)]
-    pub evaluation_retry_count: i32,
-    /// Maximum evaluation retry attempts
+pub struct DirectiveVerifier {
+    pub id: Uuid,
+    pub directive_id: Uuid,
+    pub name: String,
+    pub verifier_type: String,
+    pub command: Option<String>,
+    pub working_directory: Option<String>,
+    pub timeout_seconds: Option<i32>,
+    #[sqlx(json)]
+    #[serde(default)]
+    pub environment: serde_json::Value,
+    pub auto_detect: bool,
     #[sqlx(default)]
-    pub max_evaluation_retries: i32,
-    /// When the chain contract was created
+    pub detect_files: Vec<String>,
+    pub weight: f64,
+    pub required: bool,
+    pub enabled: bool,
+    pub last_run_at: Option<DateTime<Utc>>,
+    #[sqlx(json)]
+    pub last_result: Option<serde_json::Value>,
     pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
 }
 
-/// DAG graph structure for visualization
-#[derive(Debug, Serialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainGraphResponse {
-    pub chain_id: Uuid,
-    pub chain_name: String,
-    pub chain_status: String,
-    pub nodes: Vec<ChainGraphNode>,
-    pub edges: Vec<ChainGraphEdge>,
-}
-
-/// Node in chain DAG graph
-#[derive(Debug, Serialize, ToSchema)]
+/// Directive approval - human-in-the-loop gate
+#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainGraphNode {
+pub struct DirectiveApproval {
     pub id: Uuid,
-    pub contract_id: Uuid,
-    pub name: String,
+    pub directive_id: Uuid,
+    pub step_id: Option<Uuid>,
+    pub approval_type: String,
+    pub description: String,
+    #[sqlx(json)]
+    pub context: Option<serde_json::Value>,
+    pub urgency: String,
     pub status: String,
-    pub phase: String,
-    pub x: f64,
-    pub y: f64,
+    pub response: Option<String>,
+    pub responded_by: Option<Uuid>,
+    pub responded_at: Option<DateTime<Utc>>,
+    pub expires_at: Option<DateTime<Utc>>,
+    pub created_at: DateTime<Utc>,
 }
 
-/// Edge in chain DAG graph
-#[derive(Debug, Clone, Serialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainGraphEdge {
-    pub from: Uuid,
-    pub to: Uuid,
-}
+// =============================================================================
+// Directive Request/Response Types
+// =============================================================================
 
-/// Response for chain list endpoint
-#[derive(Debug, Serialize, ToSchema)]
+/// Request to create a directive from a goal
+#[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainListResponse {
-    pub chains: Vec<ChainSummary>,
-    pub total: i64,
+pub struct CreateDirectiveRequest {
+    pub goal: String,
+    pub title: Option<String>,
+    pub repository_url: Option<String>,
+    pub local_path: Option<String>,
+    pub base_branch: Option<String>,
+    pub autonomy_level: Option<String>,
+    pub requirements: Option<serde_json::Value>,
+    pub acceptance_criteria: Option<serde_json::Value>,
+    pub confidence_threshold_green: Option<f64>,
+    pub confidence_threshold_yellow: Option<f64>,
+    pub max_total_cost_usd: Option<f64>,
+    pub max_wall_time_minutes: Option<i32>,
 }
 
-/// Request payload for creating a new chain
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+/// Request to update a directive
+#[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct CreateChainRequest {
-    /// Name of the chain
-    pub name: String,
-    /// Optional description
-    pub description: Option<String>,
-    /// Repositories for this chain
-    pub repositories: Option<Vec<AddChainRepositoryRequest>>,
-    /// Enable loop mode for iterative execution
-    #[serde(default)]
-    pub loop_enabled: Option<bool>,
-    /// Maximum loop iterations (default: 10)
-    pub loop_max_iterations: Option<i32>,
-    /// Progress check prompt for evaluating loop completion
-    pub loop_progress_check: Option<String>,
-    /// Contracts to create within this chain
-    pub contracts: Option<Vec<CreateChainContractRequest>>,
+pub struct UpdateDirectiveRequest {
+    pub title: Option<String>,
+    pub goal: Option<String>,
+    pub requirements: Option<serde_json::Value>,
+    pub acceptance_criteria: Option<serde_json::Value>,
+    pub constraints: Option<serde_json::Value>,
+    pub external_dependencies: Option<serde_json::Value>,
+    pub autonomy_level: Option<String>,
+    pub confidence_threshold_green: Option<f64>,
+    pub confidence_threshold_yellow: Option<f64>,
+    pub max_total_cost_usd: Option<f64>,
+    pub max_wall_time_minutes: Option<i32>,
+    pub max_rework_cycles: Option<i32>,
+    pub max_chain_regenerations: Option<i32>,
+    pub version: i32,
 }
 
-/// Request to add a repository to a chain
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+/// Directive summary for list views
+#[derive(Debug, Clone, Serialize, FromRow, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct AddChainRepositoryRequest {
-    /// Display name for the repository
-    pub name: String,
-    /// Remote repository URL (for remote repos)
-    pub repository_url: Option<String>,
-    /// Local filesystem path (for local repos)
-    pub local_path: Option<String>,
-    /// Source type: remote, local, or managed
-    #[serde(default = "default_source_type")]
-    pub source_type: String,
-    /// Whether this is the primary repository
-    #[serde(default)]
-    pub is_primary: bool,
+pub struct DirectiveSummary {
+    pub id: Uuid,
+    pub title: String,
+    pub goal: String,
+    pub status: String,
+    pub autonomy_level: String,
+    pub current_confidence: Option<f64>,
+    pub completed_steps: i32,
+    pub total_steps: i32,
+    pub chain_generation_count: i32,
+    pub started_at: Option<DateTime<Utc>>,
+    pub created_at: DateTime<Utc>,
 }
 
-fn default_source_type() -> String {
-    "remote".to_string()
+/// Directive with progress, chain, events, and approvals
+#[derive(Debug, Serialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct DirectiveWithProgress {
+    #[serde(flatten)]
+    pub directive: Directive,
+    pub chain: Option<DirectiveChain>,
+    pub steps: Vec<ChainStep>,
+    pub recent_events: Vec<DirectiveEvent>,
+    pub pending_approvals: Vec<DirectiveApproval>,
 }
 
-/// Request to create a contract within a chain
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+/// Request to add a step to a chain
+#[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct CreateChainContractRequest {
-    /// Name of the contract
+pub struct AddStepRequest {
     pub name: String,
-    /// Optional description
     pub description: Option<String>,
-    /// Contract type
-    #[serde(default)]
+    pub step_type: Option<String>,
     pub contract_type: Option<String>,
-    /// Initial phase
     pub initial_phase: Option<String>,
-    /// Phases for the contract
+    pub task_plan: Option<String>,
     pub phases: Option<Vec<String>>,
-    /// Names of contracts this depends on (resolved to IDs)
-    pub depends_on: Option<Vec<String>>,
-    /// Tasks to create in this contract
-    pub tasks: Option<Vec<CreateChainTaskRequest>>,
-    /// Deliverables for this contract
-    pub deliverables: Option<Vec<CreateChainDeliverableRequest>>,
-    /// Position in GUI editor
+    pub depends_on: Option<Vec<Uuid>>,
+    pub parallel_group: Option<String>,
+    pub requirement_ids: Option<Vec<String>>,
+    pub acceptance_criteria_ids: Option<Vec<String>>,
+    pub verifier_config: Option<serde_json::Value>,
     pub editor_x: Option<f64>,
     pub editor_y: Option<f64>,
 }
 
-/// Task definition within a chain contract
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct CreateChainTaskRequest {
-    pub name: String,
-    pub plan: String,
-}
-
-/// Deliverable definition within a chain contract
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct CreateChainDeliverableRequest {
-    pub id: String,
-    pub name: String,
-    pub priority: Option<String>,
-}
-
-/// Validation configuration for checkpoint contracts.
-/// Checkpoint contracts validate the outputs of their upstream dependencies
-/// before allowing downstream contracts to proceed.
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct CheckpointValidation {
-    /// Check that all required deliverables from upstream contracts exist
-    #[serde(default)]
-    pub check_deliverables: bool,
-
-    /// Run tests in the repository (requires repository to be configured)
-    #[serde(default)]
-    pub run_tests: bool,
-
-    /// Custom validation instructions for Claude to execute.
-    /// Claude will review the outputs of upstream contracts and verify they meet these criteria.
-    pub check_content: Option<String>,
-
-    /// Action to take on validation failure: "block" (default), "retry", "warn"
-    /// - block: Fail the checkpoint and block downstream contracts
-    /// - retry: Mark upstream contracts for retry (up to max_retries)
-    /// - warn: Log warning but allow downstream to proceed
-    #[serde(default = "default_checkpoint_on_failure")]
-    pub on_failure: String,
-
-    /// Maximum retry attempts for upstream contracts (when on_failure = "retry")
-    #[serde(default = "default_checkpoint_max_retries")]
-    pub max_retries: i32,
-}
-
-fn default_checkpoint_on_failure() -> String {
-    "block".to_string()
-}
-
-fn default_checkpoint_max_retries() -> i32 {
-    3
-}
-
-impl Default for CheckpointValidation {
-    fn default() -> Self {
-        Self {
-            check_deliverables: false,
-            run_tests: false,
-            check_content: None,
-            on_failure: default_checkpoint_on_failure(),
-            max_retries: default_checkpoint_max_retries(),
-        }
-    }
-}
-
-/// Request to update an existing chain
-#[derive(Debug, Clone, Deserialize, ToSchema)]
+/// Request to update a step
+#[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct UpdateChainRequest {
+pub struct UpdateStepRequest {
     pub name: Option<String>,
     pub description: Option<String>,
-    pub status: Option<String>,
-    pub loop_enabled: Option<bool>,
-    pub loop_max_iterations: Option<i32>,
-    pub loop_progress_check: Option<String>,
-    /// Version for optimistic locking
-    pub version: Option<i32>,
-}
-
-/// Request to add a contract to a chain
-#[derive(Debug, Clone, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct AddContractToChainRequest {
-    /// Existing contract ID to add
-    pub contract_id: Option<Uuid>,
-    /// Or create a new contract with this definition
-    pub new_contract: Option<CreateChainContractRequest>,
-    /// Contract IDs this depends on
+    pub task_plan: Option<String>,
     pub depends_on: Option<Vec<Uuid>>,
-    /// Position in GUI editor
+    pub requirement_ids: Option<Vec<String>>,
+    pub acceptance_criteria_ids: Option<Vec<String>>,
+    pub verifier_config: Option<serde_json::Value>,
     pub editor_x: Option<f64>,
     pub editor_y: Option<f64>,
 }
 
-/// Editor data model for GUI chain editor
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainEditorData {
-    pub id: Option<Uuid>,
-    pub name: String,
-    pub description: Option<String>,
-    pub repositories: Vec<ChainRepository>,
-    pub loop_enabled: bool,
-    pub loop_max_iterations: Option<i32>,
-    pub loop_progress_check: Option<String>,
-    pub nodes: Vec<ChainEditorNode>,
-    pub edges: Vec<ChainEditorEdge>,
-}
-
-/// Node in chain editor
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainEditorNode {
-    pub id: String,
-    pub x: f64,
-    pub y: f64,
-    pub contract: ChainEditorContract,
-}
-
-/// Contract data in chain editor node
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainEditorContract {
-    pub name: String,
-    pub description: Option<String>,
-    #[serde(rename = "type")]
-    pub contract_type: String,
-    pub phases: Vec<String>,
-    pub tasks: Vec<ChainEditorTask>,
-    pub deliverables: Vec<ChainEditorDeliverable>,
-}
-
-/// Task in chain editor
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainEditorTask {
-    pub name: String,
-    pub plan: String,
-}
-
-/// Deliverable in chain editor
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainEditorDeliverable {
-    pub id: String,
-    pub name: String,
-    pub priority: String,
-}
-
-/// Edge in chain editor
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ChainEditorEdge {
-    pub from: String,
-    pub to: String,
-}
-
-// =============================================================================
-// Chain Contract Definitions (stored specs for on-demand contract creation)
-// =============================================================================
-
-/// Contract definition within a chain - stored spec before actual contract is created
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
+/// Chain graph response for DAG visualization
+#[derive(Debug, Serialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainContractDefinition {
-    pub id: Uuid,
+pub struct DirectiveChainGraphResponse {
     pub chain_id: Uuid,
-    pub name: String,
-    pub description: Option<String>,
-    pub contract_type: String,
-    pub initial_phase: Option<String>,
-    /// Names of other definitions this depends on
-    #[sqlx(default)]
-    pub depends_on_names: Vec<String>,
-    /// Task definitions as JSON: [{name, plan}, ...]
-    pub tasks: Option<serde_json::Value>,
-    /// Deliverable definitions as JSON: [{id, name, priority}, ...]
-    pub deliverables: Option<serde_json::Value>,
-    /// Validation configuration for checkpoint contracts (JSON)
-    pub validation: Option<serde_json::Value>,
-    /// Requirement IDs this contract addresses (for traceability)
-    #[sqlx(default)]
-    #[serde(default)]
-    pub requirement_ids: Vec<String>,
-    /// Acceptance criteria for this contract (JSON array)
-    #[serde(default)]
-    pub acceptance_criteria: Option<serde_json::Value>,
-    /// Whether LLM evaluation is enabled for this contract
-    #[serde(default = "default_evaluation_enabled")]
-    #[sqlx(default)]
-    pub evaluation_enabled: bool,
-    /// Pass threshold for evaluation (0.0-1.0)
-    pub pass_threshold: Option<f64>,
-    /// Position in GUI editor
-    pub editor_x: Option<f64>,
-    pub editor_y: Option<f64>,
-    pub order_index: i32,
-    pub created_at: DateTime<Utc>,
+    pub directive_id: Uuid,
+    pub nodes: Vec<DirectiveChainGraphNode>,
+    pub edges: Vec<DirectiveChainGraphEdge>,
 }
 
-/// Request to add a contract definition to a chain
-#[derive(Debug, Clone, Deserialize, ToSchema)]
+/// Node in directive chain graph
+#[derive(Debug, Serialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct AddContractDefinitionRequest {
+pub struct DirectiveChainGraphNode {
+    pub id: Uuid,
     pub name: String,
-    pub description: Option<String>,
-    #[serde(default = "default_contract_type")]
-    pub contract_type: String,
-    pub initial_phase: Option<String>,
-    /// Names of other definitions this depends on
-    pub depends_on: Option<Vec<String>>,
-    /// Task definitions
-    pub tasks: Option<Vec<CreateChainTaskRequest>>,
-    /// Deliverable definitions
-    pub deliverables: Option<Vec<CreateChainDeliverableRequest>>,
-    /// Validation configuration (for checkpoint contracts)
-    pub validation: Option<CheckpointValidation>,
-    /// Position in GUI editor
-    pub editor_x: Option<f64>,
-    pub editor_y: Option<f64>,
-}
-
-fn default_contract_type() -> String {
-    "simple".to_string()
-}
-
-/// Request to update a contract definition
-#[derive(Debug, Clone, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateContractDefinitionRequest {
-    pub name: Option<String>,
-    pub description: Option<String>,
-    pub contract_type: Option<String>,
-    pub initial_phase: Option<String>,
-    pub depends_on: Option<Vec<String>>,
-    pub tasks: Option<Vec<CreateChainTaskRequest>>,
-    pub deliverables: Option<Vec<CreateChainDeliverableRequest>>,
-    /// Validation configuration (for checkpoint contracts)
-    pub validation: Option<CheckpointValidation>,
+    pub step_type: String,
+    pub status: String,
+    pub confidence_score: Option<f64>,
+    pub confidence_level: Option<String>,
+    pub contract_id: Option<Uuid>,
     pub editor_x: Option<f64>,
     pub editor_y: Option<f64>,
 }
 
-/// Request to start a chain (kept for backwards compatibility)
-#[derive(Debug, Clone, Deserialize, ToSchema)]
+/// Edge in directive chain graph
+#[derive(Debug, Serialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct StartChainRequest {
-    /// Repository URL (reserved for future use)
-    pub repository_url: Option<String>,
+pub struct DirectiveChainGraphEdge {
+    pub source: Uuid,
+    pub target: Uuid,
 }
 
-/// Response when starting a chain
-#[derive(Debug, Clone, Serialize, ToSchema)]
+/// Start directive response
+#[derive(Debug, Serialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct StartChainResponse {
+pub struct StartDirectiveResponse {
+    pub directive_id: Uuid,
     pub chain_id: Uuid,
-    /// Root contracts created (those with no dependencies)
-    pub contracts_created: Vec<Uuid>,
+    pub chain_generation: i32,
+    pub steps: Vec<ChainStep>,
     pub status: String,
 }
 
-/// Graph node for definitions (before contracts are created)
-#[derive(Debug, Clone, Serialize, ToSchema)]
+/// Request to create a verifier
+#[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainDefinitionGraphNode {
-    pub id: Uuid,
+pub struct CreateVerifierRequest {
     pub name: String,
-    pub contract_type: String,
-    pub x: f64,
-    pub y: f64,
-    /// Whether this definition has been instantiated as a contract
-    pub is_instantiated: bool,
-    /// The contract ID if instantiated
-    pub contract_id: Option<Uuid>,
-    pub contract_status: Option<String>,
+    pub verifier_type: String,
+    pub command: Option<String>,
+    pub working_directory: Option<String>,
+    pub timeout_seconds: Option<i32>,
+    pub environment: Option<serde_json::Value>,
+    pub weight: Option<f64>,
+    pub required: Option<bool>,
 }
 
-/// Graph response for definitions
-#[derive(Debug, Clone, Serialize, ToSchema)]
+/// Request to update a verifier
+#[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainDefinitionGraphResponse {
-    pub chain_id: Uuid,
-    pub chain_name: String,
-    pub chain_status: String,
-    pub nodes: Vec<ChainDefinitionGraphNode>,
-    pub edges: Vec<ChainGraphEdge>,
+pub struct UpdateVerifierRequest {
+    pub name: Option<String>,
+    pub command: Option<String>,
+    pub working_directory: Option<String>,
+    pub timeout_seconds: Option<i32>,
+    pub weight: Option<f64>,
+    pub required: Option<bool>,
+    pub enabled: Option<bool>,
 }
 
-// =============================================================================
-// Chain Directives (formal specification documents for directive-driven chains)
-// =============================================================================
-
-/// Chain directive - formal specification document that drives chain creation and evaluation
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
+/// Approval action request
+#[derive(Debug, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct ChainDirective {
-    pub id: Uuid,
-    pub chain_id: Uuid,
-    pub version: i32,
-    /// Requirements as JSON: [{ id, title, description, priority, category, parentId? }]
-    #[sqlx(json)]
-    pub requirements: serde_json::Value,
-    /// Acceptance criteria as JSON: [{ id, requirementIds[], description, testable, verificationMethod }]
-    #[sqlx(json)]
-    pub acceptance_criteria: serde_json::Value,
-    /// Constraints as JSON: [{ id, type, description, impact }]
-    #[sqlx(json)]
-    pub constraints: serde_json::Value,
-    /// External dependencies as JSON: [{ id, name, type, status, requiredBy[] }]
-    #[sqlx(json)]
-    pub external_dependencies: serde_json::Value,
-    /// Source type: 'manual', 'llm_generated', 'imported'
-    pub source_type: String,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
+pub struct ApprovalActionRequest {
+    pub response: Option<String>,
 }
 
-/// Requirement in a directive
+/// Directive requirement (shared type used in directive specification)
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct DirectiveRequirement {
     pub id: String,
     pub title: String,
     pub description: String,
-    /// Priority: 'must', 'should', 'could', 'wont'
     pub priority: String,
-    /// Category: 'feature', 'infrastructure', 'testing', etc.
     pub category: Option<String>,
-    /// Parent requirement ID for hierarchical requirements
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub parent_id: Option<String>,
 }
 
-/// Acceptance criterion in a directive
+/// Directive acceptance criterion
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct DirectiveAcceptanceCriterion {
     pub id: String,
-    /// Requirement IDs this criterion validates
+    #[serde(default)]
     pub requirement_ids: Vec<String>,
     pub description: String,
+    #[serde(default = "default_true")]
     pub testable: bool,
-    /// Verification method: 'automated', 'manual', 'review', 'llm'
-    pub verification_method: String,
+    pub verification_method: Option<String>,
 }
 
-/// Constraint in a directive
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct DirectiveConstraint {
-    pub id: String,
-    /// Type: 'technical', 'business', 'time', 'resource'
-    #[serde(rename = "type")]
-    pub constraint_type: String,
-    pub description: String,
-    /// Impact: 'high', 'medium', 'low'
-    pub impact: String,
+fn default_true() -> bool {
+    true
 }
 
-/// External dependency in a directive
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct DirectiveExternalDependency {
-    pub id: String,
-    pub name: String,
-    /// Type: 'api', 'service', 'library', 'data'
-    #[serde(rename = "type")]
-    pub dependency_type: String,
-    /// Status: 'available', 'pending', 'blocked'
-    pub status: String,
-    /// Requirement IDs that need this dependency
-    pub required_by: Vec<String>,
-}
+// Old chain types (Chain, ChainContract, ChainContractDefinition, ChainDirective,
+// ContractEvaluation, ChainEvent, ChainRepository, etc.) have been replaced by
+// the directive system above: Directive, DirectiveChain, ChainStep,
+// DirectiveEvaluation, DirectiveEvent, DirectiveVerifier, DirectiveApproval.
 
-/// Request to create or update a chain directive
-#[derive(Debug, Clone, Deserialize, ToSchema)]
+// Legacy types kept temporarily for chain runner/parser compatibility during migration.
+// These will be removed once the chain daemon module is replaced.
+
+/// Request payload for creating a new chain (legacy - used by chain runner)
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct CreateChainDirectiveRequest {
-    pub requirements: Option<Vec<DirectiveRequirement>>,
-    pub acceptance_criteria: Option<Vec<DirectiveAcceptanceCriterion>>,
-    pub constraints: Option<Vec<DirectiveConstraint>>,
-    pub external_dependencies: Option<Vec<DirectiveExternalDependency>>,
-    pub source_type: Option<String>,
+pub struct CreateChainRequest {
+    pub name: String,
+    pub description: Option<String>,
+    pub repository_url: Option<String>,
+    pub repositories: Option<Vec<AddChainRepositoryRequest>>,
+    pub loop_enabled: Option<bool>,
+    pub loop_max_iterations: Option<i32>,
+    pub loop_progress_check: Option<String>,
+    pub contracts: Option<Vec<CreateChainContractRequest>>,
 }
 
-/// Request to initialize a directive-driven chain
-#[derive(Debug, Clone, Deserialize, ToSchema)]
+/// Request to add a repository to a chain (legacy - used by chain runner)
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct InitChainRequest {
-    /// High-level goal/description for the directive contract
-    pub goal: String,
-    /// Repository URL for chain contracts
+pub struct AddChainRepositoryRequest {
+    pub name: String,
     pub repository_url: Option<String>,
-    /// Local path for chain contracts
     pub local_path: Option<String>,
-    /// Whether to enable phase guard (user approval between phases)
+    #[serde(default = "default_source_type")]
+    pub source_type: String,
     #[serde(default)]
-    pub phase_guard: bool,
-}
-
-/// Response from initializing a directive-driven chain
-#[derive(Debug, Clone, Serialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct InitChainResponse {
-    pub chain_id: Uuid,
-    pub directive_contract_id: Uuid,
-    pub supervisor_task_id: Option<Uuid>,
-}
-
-// =============================================================================
-// Contract Evaluations (LLM evaluation results for completed contracts)
-// =============================================================================
-
-/// Evaluation status for chain contracts
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum EvaluationStatus {
-    /// Not yet evaluated
-    Pending,
-    /// Currently being evaluated
-    Evaluating,
-    /// Evaluation passed
-    Passed,
-    /// Evaluation failed
-    Failed,
-    /// Contract is being reworked after failed evaluation
-    Rework,
-    /// Max retries exceeded, escalated to user
-    Escalated,
-    /// User approved despite partial failure
-    ApprovedWithIssues,
-}
-
-impl std::fmt::Display for EvaluationStatus {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Pending => write!(f, "pending"),
-            Self::Evaluating => write!(f, "evaluating"),
-            Self::Passed => write!(f, "passed"),
-            Self::Failed => write!(f, "failed"),
-            Self::Rework => write!(f, "rework"),
-            Self::Escalated => write!(f, "escalated"),
-            Self::ApprovedWithIssues => write!(f, "approved_with_issues"),
-        }
-    }
-}
-
-impl std::str::FromStr for EvaluationStatus {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "pending" => Ok(Self::Pending),
-            "evaluating" => Ok(Self::Evaluating),
-            "passed" => Ok(Self::Passed),
-            "failed" => Ok(Self::Failed),
-            "rework" => Ok(Self::Rework),
-            "escalated" => Ok(Self::Escalated),
-            "approved_with_issues" => Ok(Self::ApprovedWithIssues),
-            _ => Err(format!("Unknown evaluation status: {}", s)),
-        }
-    }
-}
-
-/// Contract evaluation - LLM evaluation result after contract completion
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ContractEvaluation {
-    pub id: Uuid,
-    pub contract_id: Uuid,
-    pub chain_id: Option<Uuid>,
-    pub chain_contract_id: Option<Uuid>,
-    /// Evaluation attempt number (1-based)
-    pub evaluation_number: i32,
-    /// Model used for evaluation
-    pub evaluator_model: Option<String>,
-    /// Whether the evaluation passed
-    pub passed: bool,
-    /// Overall score (0.0-1.0)
-    pub overall_score: Option<f64>,
-    /// Per-criterion results as JSON
-    #[sqlx(json)]
-    pub criteria_results: serde_json::Value,
-    /// Summary feedback from the evaluator
-    pub summary_feedback: String,
-    /// Instructions for rework if evaluation failed
-    pub rework_instructions: Option<String>,
-    /// Snapshot of directive at evaluation time
-    pub directive_snapshot: Option<serde_json::Value>,
-    /// Snapshot of deliverables at evaluation time
-    pub deliverables_snapshot: Option<serde_json::Value>,
-    pub started_at: DateTime<Utc>,
-    pub completed_at: Option<DateTime<Utc>>,
-    pub created_at: DateTime<Utc>,
-}
-
-/// Per-criterion evaluation result
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct EvaluationCriterionResult {
-    pub criterion_id: String,
-    pub criterion_text: String,
-    pub passed: bool,
-    /// Score (0.0-1.0)
-    pub score: f64,
-    pub feedback: String,
-    /// Evidence supporting the evaluation
-    pub evidence: Vec<String>,
-}
-
-/// Request to create a contract evaluation
-#[derive(Debug, Clone, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct CreateContractEvaluationRequest {
-    pub contract_id: Uuid,
-    pub chain_id: Option<Uuid>,
-    pub chain_contract_id: Option<Uuid>,
-    pub evaluator_model: Option<String>,
-    pub passed: bool,
-    pub overall_score: Option<f64>,
-    pub criteria_results: Vec<EvaluationCriterionResult>,
-    pub summary_feedback: String,
-    pub rework_instructions: Option<String>,
+    pub is_primary: bool,
 }
 
-/// Summary of contract evaluation for list views
-#[derive(Debug, Clone, FromRow, Serialize, Deserialize, ToSchema)]
-#[serde(rename_all = "camelCase")]
-pub struct ContractEvaluationSummary {
-    pub id: Uuid,
-    pub contract_id: Uuid,
-    pub evaluation_number: i32,
-    pub passed: bool,
-    pub overall_score: Option<f64>,
-    pub summary_feedback: String,
-    pub created_at: DateTime<Utc>,
+fn default_source_type() -> String {
+    "remote".to_string()
 }
 
-/// Response listing evaluations for a chain or contract
-#[derive(Debug, Clone, Serialize, ToSchema)]
+/// Request to create a contract within a chain (legacy - used by chain runner)
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ContractEvaluationsResponse {
-    pub evaluations: Vec<ContractEvaluationSummary>,
-    pub total: i64,
+pub struct CreateChainContractRequest {
+    pub name: String,
+    pub description: Option<String>,
+    #[serde(default)]
+    pub contract_type: Option<String>,
+    pub initial_phase: Option<String>,
+    pub phases: Option<Vec<String>>,
+    pub depends_on: Option<Vec<String>>,
+    pub tasks: Option<Vec<CreateChainTaskRequest>>,
+    pub deliverables: Option<Vec<CreateChainDeliverableRequest>>,
+    pub editor_x: Option<f64>,
+    pub editor_y: Option<f64>,
 }
 
-/// Traceability matrix entry - maps requirements to contracts
-#[derive(Debug, Clone, Serialize, ToSchema)]
+/// Task definition within a chain contract (legacy - used by chain runner)
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct TraceabilityEntry {
-    pub requirement_id: String,
-    pub requirement_title: String,
-    pub contract_definition_ids: Vec<Uuid>,
-    pub contract_definition_names: Vec<String>,
-    pub acceptance_criteria_ids: Vec<String>,
+pub struct CreateChainTaskRequest {
+    pub name: String,
+    pub plan: String,
 }
 
-/// Response for directive traceability
-#[derive(Debug, Clone, Serialize, ToSchema)]
+/// Deliverable definition within a chain contract (legacy - used by chain runner)
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct DirectiveTraceabilityResponse {
-    pub chain_id: Uuid,
-    pub entries: Vec<TraceabilityEntry>,
-    /// Requirements not mapped to any contract
-    pub uncovered_requirements: Vec<String>,
+pub struct CreateChainDeliverableRequest {
+    pub id: String,
+    pub name: String,
+    pub priority: Option<String>,
 }
 
 // =============================================================================
diff --git a/makima/src/db/repository.rs b/makima/src/db/repository.rs
index 7be7bc8..eeda4a5 100644
--- a/makima/src/db/repository.rs
+++ b/makima/src/db/repository.rs
@@ -6,23 +6,22 @@ use sqlx::PgPool;
 use uuid::Uuid;
 
 use super::models::{
-    AddChainRepositoryRequest, AddContractDefinitionRequest, AddContractToChainRequest, Chain,
-    ChainContract, ChainContractDefinition, ChainContractDetail, ChainDefinitionGraphNode,
-    ChainDefinitionGraphResponse, ChainDirective, ChainEditorContract, ChainEditorData,
-    ChainEditorDeliverable, ChainEditorEdge, ChainEditorNode, ChainEditorTask, ChainEvent,
-    ChainGraphEdge, ChainGraphNode, ChainGraphResponse, ChainRepository, ChainSummary,
-    ChainWithContracts, CheckpointPatch, CheckpointPatchInfo, Contract, ContractChatConversation,
-    ContractChatMessageRecord, ContractEvaluation, ContractEvaluationSummary, ContractEvent,
-    ContractRepository, ContractSummary, ContractTypeTemplateRecord, ConversationMessage,
-    ConversationSnapshot, CreateChainDirectiveRequest, CreateChainRequest,
-    CreateContractEvaluationRequest, CreateContractRequest, CreateFileRequest, CreateTaskRequest,
-    CreateTemplateRequest, Daemon, DaemonTaskAssignment, DaemonWithCapacity, DeliverableDefinition,
-    DirectiveTraceabilityResponse, EvaluationCriterionResult, File, FileSummary, FileVersion,
-    HistoryEvent, HistoryQueryFilters, InitChainRequest, InitChainResponse, MeshChatConversation,
-    MeshChatMessageRecord, PhaseChangeResult, PhaseConfig, PhaseDefinition,
-    SupervisorHeartbeatRecord, SupervisorState, Task, TaskCheckpoint, TaskEvent, TaskSummary,
-    TraceabilityEntry, UpdateChainRequest, UpdateContractDefinitionRequest, UpdateContractRequest,
-    UpdateFileRequest, UpdateTaskRequest, UpdateTemplateRequest,
+    // Core types
+    CheckpointPatch, CheckpointPatchInfo, Contract, ContractChatConversation,
+    ContractChatMessageRecord, ContractEvent, ContractRepository, ContractSummary,
+    ContractTypeTemplateRecord, ConversationMessage, ConversationSnapshot,
+    CreateContractRequest, CreateFileRequest, CreateTaskRequest, CreateTemplateRequest,
+    Daemon, DaemonTaskAssignment, DaemonWithCapacity, DeliverableDefinition,
+    File, FileSummary, FileVersion, HistoryEvent, HistoryQueryFilters,
+    MeshChatConversation, MeshChatMessageRecord, PhaseChangeResult, PhaseConfig,
+    PhaseDefinition, SupervisorHeartbeatRecord, SupervisorState, Task, TaskCheckpoint,
+    TaskEvent, TaskSummary, UpdateContractRequest, UpdateFileRequest, UpdateTaskRequest,
+    UpdateTemplateRequest,
+    // Directive types
+    AddStepRequest, ChainStep, CreateDirectiveRequest, Directive, DirectiveApproval,
+    DirectiveChain, DirectiveChainGraphEdge, DirectiveChainGraphNode, DirectiveChainGraphResponse,
+    DirectiveEvaluation, DirectiveEvent, DirectiveSummary, DirectiveVerifier,
+    DirectiveWithProgress, UpdateDirectiveRequest, UpdateStepRequest,
 };
 
 /// Repository error types.
@@ -4906,46 +4905,140 @@ pub async fn sync_supervisor_state(
 }
 
 // =============================================================================
-// Chain Operations (DAG of contracts for multi-contract orchestration)
+// Directive Operations (top-level orchestration entity)
 // =============================================================================
+// TODO: Implement directive CRUD functions
+// - create_directive_for_owner
+// - get_directive_for_owner
+// - list_directives_for_owner
+// - update_directive_for_owner
+// - archive_directive_for_owner
+// - update_directive_status
 
-/// Create a new chain for a specific owner.
-pub async fn create_chain_for_owner(
+// =============================================================================
+// Directive Chain Operations (generated execution plans)
+// =============================================================================
+// TODO: Implement chain CRUD functions
+// - create_directive_chain
+// - get_current_chain
+// - supersede_chain
+
+// =============================================================================
+// Chain Step Operations (nodes in the DAG)
+// =============================================================================
+// TODO: Implement step CRUD functions
+// - create_chain_step
+// - update_chain_step
+// - delete_chain_step
+// - find_ready_steps
+// - update_step_status
+// - update_step_contract
+// - update_step_confidence
+// - increment_step_rework_count
+
+// =============================================================================
+// Directive Evaluation Operations
+// =============================================================================
+// TODO: Implement evaluation functions
+// - create_directive_evaluation
+// - list_step_evaluations
+// - list_directive_evaluations
+
+// =============================================================================
+// Directive Event Operations (audit stream)
+// =============================================================================
+// TODO: Implement event functions
+// - emit_directive_event
+// - list_directive_events
+
+// =============================================================================
+// Directive Verifier Operations
+// =============================================================================
+// TODO: Implement verifier CRUD functions
+// - create_directive_verifier
+// - list_directive_verifiers
+// - update_directive_verifier
+
+// =============================================================================
+// Directive Approval Operations (human-in-the-loop)
+// =============================================================================
+// TODO: Implement approval functions
+// - create_approval_request
+// - resolve_approval
+// - list_pending_approvals
+
+// NOTE: Old chain functions removed. See git history for reference.
+// Old functions included: create_chain_for_owner, get_chain_for_owner,
+// list_chains_for_owner, update_chain_for_owner, delete_chain_for_owner,
+// add_contract_to_chain, remove_contract_from_chain, list_chain_contracts,
+// get_chain_with_contracts, list_chain_repositories, add_chain_repository,
+// delete_chain_repository, set_chain_repository_primary, get_chain_graph,
+// record_chain_event, list_chain_events, increment_chain_loop, complete_chain,
+// get_ready_chain_contracts, is_chain_complete, get_chain_editor_data,
+// create_chain_contract_definition, list_chain_contract_definitions,
+// update_chain_contract_definition, delete_chain_contract_definition,
+// get_chain_definition_graph, update_chain_status, progress_chain,
+// create_chain_directive, get_chain_directive, update_chain_directive,
+// delete_chain_directive, create_contract_evaluation, get_contract_evaluation,
+// list_chain_evaluations, update_chain_contract_evaluation_status,
+// mark_chain_contract_original_completion, get_chain_contract_by_contract_id,
+// init_chain_for_owner.
+
+// =============================================================================
+// Directive Operations
+// =============================================================================
+
+/// Create a new directive for an owner.
+pub async fn create_directive_for_owner(
     pool: &PgPool,
     owner_id: Uuid,
-    req: CreateChainRequest,
-) -> Result<Chain, sqlx::Error> {
-    let loop_enabled = req.loop_enabled.unwrap_or(false);
-    let loop_max_iterations = req.loop_max_iterations.unwrap_or(10);
-
-    sqlx::query_as::<_, Chain>(
-        r#"
-        INSERT INTO chains (owner_id, name, description, loop_enabled, loop_max_iterations, loop_progress_check)
-        VALUES ($1, $2, $3, $4, $5, $6)
+    req: CreateDirectiveRequest,
+) -> Result<Directive, sqlx::Error> {
+    let title = req.title.unwrap_or_else(|| truncate_string(&req.goal, 100));
+    let autonomy_level = req.autonomy_level.unwrap_or_else(|| "guardrails".to_string());
+    let green_threshold = req.confidence_threshold_green.unwrap_or(0.85);
+    let yellow_threshold = req.confidence_threshold_yellow.unwrap_or(0.60);
+    let requirements = req.requirements.unwrap_or(serde_json::json!([]));
+    let acceptance_criteria = req.acceptance_criteria.unwrap_or(serde_json::json!([]));
+
+    sqlx::query_as::<_, Directive>(
+        r#"
+        INSERT INTO directives (
+            owner_id, title, goal, requirements, acceptance_criteria,
+            autonomy_level, confidence_threshold_green, confidence_threshold_yellow,
+            repository_url, local_path, base_branch,
+            max_total_cost_usd, max_wall_time_minutes
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
         RETURNING *
         "#,
     )
     .bind(owner_id)
-    .bind(&req.name)
-    .bind(&req.description)
-    .bind(loop_enabled)
-    .bind(loop_max_iterations)
-    .bind(&req.loop_progress_check)
+    .bind(&title)
+    .bind(&req.goal)
+    .bind(&requirements)
+    .bind(&acceptance_criteria)
+    .bind(&autonomy_level)
+    .bind(green_threshold)
+    .bind(yellow_threshold)
+    .bind(&req.repository_url)
+    .bind(&req.local_path)
+    .bind(&req.base_branch)
+    .bind(req.max_total_cost_usd)
+    .bind(req.max_wall_time_minutes)
     .fetch_one(pool)
     .await
 }
 
-/// Get a chain by ID, scoped to owner.
-pub async fn get_chain_for_owner(
+/// Get a directive by ID, scoped to owner.
+pub async fn get_directive_for_owner(
     pool: &PgPool,
     id: Uuid,
     owner_id: Uuid,
-) -> Result<Option<Chain>, sqlx::Error> {
-    sqlx::query_as::<_, Chain>(
+) -> Result<Option<Directive>, sqlx::Error> {
+    sqlx::query_as::<_, Directive>(
         r#"
-        SELECT *
-        FROM chains
-        WHERE id = $1 AND owner_id = $2
+        SELECT * FROM directives WHERE id = $1 AND owner_id = $2
         "#,
     )
     .bind(id)
@@ -4954,817 +5047,485 @@ pub async fn get_chain_for_owner(
     .await
 }
 
-/// Get a chain by ID (no owner check - for internal use).
-pub async fn get_chain(pool: &PgPool, id: Uuid) -> Result<Option<Chain>, sqlx::Error> {
-    sqlx::query_as::<_, Chain>(
-        r#"
-        SELECT *
-        FROM chains
-        WHERE id = $1
-        "#,
+/// Get a directive by ID (no owner check - for internal use).
+pub async fn get_directive(pool: &PgPool, id: Uuid) -> Result<Option<Directive>, sqlx::Error> {
+    sqlx::query_as::<_, Directive>(
+        r#"SELECT * FROM directives WHERE id = $1"#,
     )
     .bind(id)
     .fetch_optional(pool)
     .await
 }
 
-/// List chains for a specific owner.
-pub async fn list_chains_for_owner(
+/// List directives for an owner.
+pub async fn list_directives_for_owner(
     pool: &PgPool,
     owner_id: Uuid,
-) -> Result<Vec<ChainSummary>, sqlx::Error> {
-    sqlx::query_as::<_, ChainSummary>(
-        r#"
-        SELECT
-            c.id,
-            c.name,
-            c.description,
-            c.status,
-            c.loop_enabled,
-            c.loop_current_iteration,
-            COUNT(DISTINCT cc.contract_id) as contract_count,
-            COUNT(DISTINCT CASE WHEN con.status = 'completed' THEN cc.contract_id END) as completed_count,
-            c.version,
-            c.created_at
-        FROM chains c
-        LEFT JOIN chain_contracts cc ON cc.chain_id = c.id
-        LEFT JOIN contracts con ON con.id = cc.contract_id
-        WHERE c.owner_id = $1
-        GROUP BY c.id
-        ORDER BY c.created_at DESC
-        "#,
-    )
-    .bind(owner_id)
-    .fetch_all(pool)
-    .await
+    status_filter: Option<&str>,
+) -> Result<Vec<DirectiveSummary>, sqlx::Error> {
+    let query = if let Some(status) = status_filter {
+        sqlx::query_as::<_, DirectiveSummary>(
+            r#"
+            SELECT
+                d.id, d.title, d.goal, d.status, d.autonomy_level,
+                dc.current_confidence,
+                COALESCE(dc.completed_steps, 0) as completed_steps,
+                COALESCE(dc.total_steps, 0) as total_steps,
+                d.chain_generation_count, d.started_at, d.created_at
+            FROM directives d
+            LEFT JOIN directive_chains dc ON dc.id = d.current_chain_id
+            WHERE d.owner_id = $1 AND d.status = $2
+            ORDER BY d.created_at DESC
+            "#,
+        )
+        .bind(owner_id)
+        .bind(status)
+    } else {
+        sqlx::query_as::<_, DirectiveSummary>(
+            r#"
+            SELECT
+                d.id, d.title, d.goal, d.status, d.autonomy_level,
+                dc.current_confidence,
+                COALESCE(dc.completed_steps, 0) as completed_steps,
+                COALESCE(dc.total_steps, 0) as total_steps,
+                d.chain_generation_count, d.started_at, d.created_at
+            FROM directives d
+            LEFT JOIN directive_chains dc ON dc.id = d.current_chain_id
+            WHERE d.owner_id = $1
+            ORDER BY d.created_at DESC
+            "#,
+        )
+        .bind(owner_id)
+    };
+    query.fetch_all(pool).await
 }
 
-/// Update a chain.
-pub async fn update_chain_for_owner(
+/// Update a directive with optimistic locking.
+pub async fn update_directive_for_owner(
     pool: &PgPool,
     id: Uuid,
     owner_id: Uuid,
-    req: UpdateChainRequest,
-) -> Result<Chain, RepositoryError> {
-    // First get current version if optimistic locking requested
-    if let Some(expected_version) = req.version {
-        let current: Option<(i32,)> = sqlx::query_as(
-            "SELECT version FROM chains WHERE id = $1 AND owner_id = $2",
-        )
-        .bind(id)
-        .bind(owner_id)
-        .fetch_optional(pool)
-        .await?;
+    req: UpdateDirectiveRequest,
+) -> Result<Directive, RepositoryError> {
+    // First get current version
+    let current = sqlx::query_scalar::<_, i32>(
+        "SELECT version FROM directives WHERE id = $1 AND owner_id = $2"
+    )
+    .bind(id)
+    .bind(owner_id)
+    .fetch_optional(pool)
+    .await?
+    .ok_or_else(|| RepositoryError::Database(sqlx::Error::RowNotFound))?;
 
-        if let Some((actual_version,)) = current {
-            if actual_version != expected_version {
-                return Err(RepositoryError::VersionConflict {
-                    expected: expected_version,
-                    actual: actual_version,
-                });
-            }
-        }
+    if current != req.version {
+        return Err(RepositoryError::VersionConflict {
+            expected: req.version,
+            actual: current,
+        });
     }
 
-    let result = sqlx::query_as::<_, Chain>(
-        r#"
-        UPDATE chains
-        SET
-            name = COALESCE($3, name),
-            description = COALESCE($4, description),
-            status = COALESCE($5, status),
-            loop_enabled = COALESCE($6, loop_enabled),
-            loop_max_iterations = COALESCE($7, loop_max_iterations),
-            loop_progress_check = COALESCE($8, loop_progress_check),
+    let directive = sqlx::query_as::<_, Directive>(
+        r#"
+        UPDATE directives SET
+            title = COALESCE($3, title),
+            goal = COALESCE($4, goal),
+            requirements = COALESCE($5, requirements),
+            acceptance_criteria = COALESCE($6, acceptance_criteria),
+            constraints = COALESCE($7, constraints),
+            external_dependencies = COALESCE($8, external_dependencies),
+            autonomy_level = COALESCE($9, autonomy_level),
+            confidence_threshold_green = COALESCE($10, confidence_threshold_green),
+            confidence_threshold_yellow = COALESCE($11, confidence_threshold_yellow),
+            max_total_cost_usd = COALESCE($12, max_total_cost_usd),
+            max_wall_time_minutes = COALESCE($13, max_wall_time_minutes),
+            max_rework_cycles = COALESCE($14, max_rework_cycles),
+            max_chain_regenerations = COALESCE($15, max_chain_regenerations),
             version = version + 1,
             updated_at = NOW()
-        WHERE id = $1 AND owner_id = $2
+        WHERE id = $1 AND owner_id = $2 AND version = $16
         RETURNING *
         "#,
     )
     .bind(id)
     .bind(owner_id)
-    .bind(&req.name)
-    .bind(&req.description)
-    .bind(&req.status)
-    .bind(req.loop_enabled)
-    .bind(req.loop_max_iterations)
-    .bind(&req.loop_progress_check)
+    .bind(&req.title)
+    .bind(&req.goal)
+    .bind(&req.requirements)
+    .bind(&req.acceptance_criteria)
+    .bind(&req.constraints)
+    .bind(&req.external_dependencies)
+    .bind(&req.autonomy_level)
+    .bind(req.confidence_threshold_green)
+    .bind(req.confidence_threshold_yellow)
+    .bind(req.max_total_cost_usd)
+    .bind(req.max_wall_time_minutes)
+    .bind(req.max_rework_cycles)
+    .bind(req.max_chain_regenerations)
+    .bind(req.version)
     .fetch_one(pool)
     .await?;
 
-    Ok(result)
+    Ok(directive)
 }
 
-/// Delete (archive) a chain.
-pub async fn delete_chain_for_owner(
+/// Update directive status.
+pub async fn update_directive_status(
     pool: &PgPool,
     id: Uuid,
-    owner_id: Uuid,
-) -> Result<bool, sqlx::Error> {
-    let result = sqlx::query(
-        r#"
-        UPDATE chains
-        SET status = 'archived', updated_at = NOW()
-        WHERE id = $1 AND owner_id = $2
-        "#,
-    )
-    .bind(id)
-    .bind(owner_id)
-    .execute(pool)
-    .await?;
-
-    Ok(result.rows_affected() > 0)
-}
-
-/// Add a contract to a chain.
-pub async fn add_contract_to_chain(
-    pool: &PgPool,
-    chain_id: Uuid,
-    contract_id: Uuid,
-    depends_on: Vec<Uuid>,
-    order_index: i32,
-    editor_x: Option<f64>,
-    editor_y: Option<f64>,
-) -> Result<ChainContract, sqlx::Error> {
-    // Also update the contract's chain_id
-    sqlx::query("UPDATE contracts SET chain_id = $1 WHERE id = $2")
-        .bind(chain_id)
-        .bind(contract_id)
-        .execute(pool)
-        .await?;
-
-    sqlx::query_as::<_, ChainContract>(
+    status: &str,
+) -> Result<Directive, sqlx::Error> {
+    sqlx::query_as::<_, Directive>(
         r#"
-        INSERT INTO chain_contracts (chain_id, contract_id, depends_on, order_index, editor_x, editor_y)
-        VALUES ($1, $2, $3, $4, $5, $6)
-        ON CONFLICT (chain_id, contract_id) DO UPDATE SET
-            depends_on = EXCLUDED.depends_on,
-            order_index = EXCLUDED.order_index,
-            editor_x = EXCLUDED.editor_x,
-            editor_y = EXCLUDED.editor_y
+        UPDATE directives SET
+            status = $2,
+            started_at = CASE WHEN $2 = 'active' AND started_at IS NULL THEN NOW() ELSE started_at END,
+            completed_at = CASE WHEN $2 IN ('completed', 'failed', 'archived') THEN NOW() ELSE completed_at END,
+            updated_at = NOW()
+        WHERE id = $1
         RETURNING *
         "#,
     )
-    .bind(chain_id)
-    .bind(contract_id)
-    .bind(&depends_on)
-    .bind(order_index)
-    .bind(editor_x)
-    .bind(editor_y)
+    .bind(id)
+    .bind(status)
     .fetch_one(pool)
     .await
 }
 
-/// Remove a contract from a chain.
-pub async fn remove_contract_from_chain(
+/// Archive a directive (soft delete).
+pub async fn archive_directive_for_owner(
     pool: &PgPool,
-    chain_id: Uuid,
-    contract_id: Uuid,
+    id: Uuid,
+    owner_id: Uuid,
 ) -> Result<bool, sqlx::Error> {
-    // Clear the contract's chain_id
-    sqlx::query("UPDATE contracts SET chain_id = NULL WHERE id = $1 AND chain_id = $2")
-        .bind(contract_id)
-        .bind(chain_id)
-        .execute(pool)
-        .await?;
-
     let result = sqlx::query(
         r#"
-        DELETE FROM chain_contracts
-        WHERE chain_id = $1 AND contract_id = $2
+        UPDATE directives SET status = 'archived', updated_at = NOW()
+        WHERE id = $1 AND owner_id = $2
         "#,
     )
-    .bind(chain_id)
-    .bind(contract_id)
+    .bind(id)
+    .bind(owner_id)
     .execute(pool)
     .await?;
-
     Ok(result.rows_affected() > 0)
 }
 
-/// List contracts in a chain with their details.
-pub async fn list_chain_contracts(
-    pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Vec<ChainContractDetail>, sqlx::Error> {
-    sqlx::query_as::<_, ChainContractDetail>(
-        r#"
-        SELECT
-            cc.id as chain_contract_id,
-            cc.contract_id,
-            c.name as contract_name,
-            c.status as contract_status,
-            c.phase as contract_phase,
-            cc.depends_on,
-            cc.order_index,
-            cc.editor_x,
-            cc.editor_y,
-            cc.evaluation_status,
-            cc.evaluation_retry_count,
-            cc.max_evaluation_retries,
-            cc.created_at
-        FROM chain_contracts cc
-        JOIN contracts c ON c.id = cc.contract_id
-        WHERE cc.chain_id = $1
-        ORDER BY cc.order_index ASC
-        "#,
-    )
-    .bind(chain_id)
-    .fetch_all(pool)
-    .await
-}
-
-/// Get chain with all contracts for detail view.
-pub async fn get_chain_with_contracts(
+/// Get directive with full progress info.
+pub async fn get_directive_with_progress(
     pool: &PgPool,
-    chain_id: Uuid,
+    id: Uuid,
     owner_id: Uuid,
-) -> Result<Option<ChainWithContracts>, sqlx::Error> {
-    let chain = get_chain_for_owner(pool, chain_id, owner_id).await?;
-
-    match chain {
-        Some(chain) => {
-            let contracts = list_chain_contracts(pool, chain_id).await?;
-            let repositories = list_chain_repositories(pool, chain_id).await?;
-            Ok(Some(ChainWithContracts {
-                chain,
-                contracts,
-                repositories,
-            }))
-        }
-        None => Ok(None),
-    }
-}
+) -> Result<Option<DirectiveWithProgress>, sqlx::Error> {
+    let directive = match get_directive_for_owner(pool, id, owner_id).await? {
+        Some(d) => d,
+        None => return Ok(None),
+    };
 
-// =============================================================================
-// Chain Repository Operations
-// =============================================================================
+    let chain = if let Some(chain_id) = directive.current_chain_id {
+        get_directive_chain(pool, chain_id).await?
+    } else {
+        None
+    };
 
-/// List all repositories for a chain.
-pub async fn list_chain_repositories(
-    pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Vec<ChainRepository>, sqlx::Error> {
-    sqlx::query_as::<_, ChainRepository>(
-        r#"
-        SELECT *
-        FROM chain_repositories
-        WHERE chain_id = $1
-        ORDER BY is_primary DESC, created_at ASC
-        "#,
-    )
-    .bind(chain_id)
-    .fetch_all(pool)
-    .await
-}
+    let steps = if let Some(ref c) = chain {
+        list_chain_steps(pool, c.id).await?
+    } else {
+        vec![]
+    };
 
-/// Get a chain repository by ID.
-pub async fn get_chain_repository(
-    pool: &PgPool,
-    chain_id: Uuid,
-    repository_id: Uuid,
-) -> Result<Option<ChainRepository>, sqlx::Error> {
-    sqlx::query_as::<_, ChainRepository>(
-        r#"
-        SELECT *
-        FROM chain_repositories
-        WHERE id = $1 AND chain_id = $2
-        "#,
-    )
-    .bind(repository_id)
-    .bind(chain_id)
-    .fetch_optional(pool)
-    .await
+    let recent_events = list_directive_events(pool, id, Some(20)).await?;
+    let pending_approvals = list_pending_approvals(pool, id).await?;
+
+    Ok(Some(DirectiveWithProgress {
+        directive,
+        chain,
+        steps,
+        recent_events,
+        pending_approvals,
+    }))
 }
 
-/// Add a repository to a chain.
-pub async fn add_chain_repository(
+// =============================================================================
+// Directive Chain Operations
+// =============================================================================
+
+/// Create a new chain generation for a directive.
+pub async fn create_directive_chain(
     pool: &PgPool,
-    chain_id: Uuid,
-    req: &AddChainRepositoryRequest,
-) -> Result<ChainRepository, sqlx::Error> {
-    // If is_primary, clear other primaries first
-    if req.is_primary {
-        sqlx::query(
-            r#"
-            UPDATE chain_repositories
-            SET is_primary = false, updated_at = NOW()
-            WHERE chain_id = $1 AND is_primary = true
-            "#,
-        )
-        .bind(chain_id)
-        .execute(pool)
-        .await?;
-    }
+    directive_id: Uuid,
+    name: &str,
+    description: Option<&str>,
+    rationale: Option<&str>,
+    planning_model: Option<&str>,
+) -> Result<DirectiveChain, sqlx::Error> {
+    // Get next generation number
+    let generation = sqlx::query_scalar::<_, i32>(
+        "SELECT COALESCE(MAX(generation), 0) + 1 FROM directive_chains WHERE directive_id = $1"
+    )
+    .bind(directive_id)
+    .fetch_one(pool)
+    .await?;
 
-    sqlx::query_as::<_, ChainRepository>(
+    let chain = sqlx::query_as::<_, DirectiveChain>(
         r#"
-        INSERT INTO chain_repositories (chain_id, name, repository_url, local_path, source_type, status, is_primary)
-        VALUES ($1, $2, $3, $4, $5, 'ready', $6)
+        INSERT INTO directive_chains (directive_id, generation, name, description, rationale, planning_model)
+        VALUES ($1, $2, $3, $4, $5, $6)
         RETURNING *
         "#,
     )
-    .bind(chain_id)
-    .bind(&req.name)
-    .bind(&req.repository_url)
-    .bind(&req.local_path)
-    .bind(&req.source_type)
-    .bind(req.is_primary)
+    .bind(directive_id)
+    .bind(generation)
+    .bind(name)
+    .bind(description)
+    .bind(rationale)
+    .bind(planning_model)
     .fetch_one(pool)
-    .await
-}
-
-/// Delete a repository from a chain.
-pub async fn delete_chain_repository(
-    pool: &PgPool,
-    chain_id: Uuid,
-    repository_id: Uuid,
-) -> Result<bool, sqlx::Error> {
-    let result = sqlx::query(
-        r#"
-        DELETE FROM chain_repositories
-        WHERE id = $1 AND chain_id = $2
-        "#,
-    )
-    .bind(repository_id)
-    .bind(chain_id)
-    .execute(pool)
     .await?;
 
-    Ok(result.rows_affected() > 0)
-}
-
-/// Set a repository as primary for a chain.
-pub async fn set_chain_repository_primary(
-    pool: &PgPool,
-    chain_id: Uuid,
-    repository_id: Uuid,
-) -> Result<ChainRepository, sqlx::Error> {
-    // Clear existing primary
+    // Update directive to point to new chain and increment generation count
     sqlx::query(
         r#"
-        UPDATE chain_repositories
-        SET is_primary = false, updated_at = NOW()
-        WHERE chain_id = $1 AND is_primary = true
+        UPDATE directives SET
+            current_chain_id = $2,
+            chain_generation_count = chain_generation_count + 1,
+            updated_at = NOW()
+        WHERE id = $1
         "#,
     )
-    .bind(chain_id)
+    .bind(directive_id)
+    .bind(chain.id)
     .execute(pool)
     .await?;
 
-    // Set new primary
-    sqlx::query_as::<_, ChainRepository>(
-        r#"
-        UPDATE chain_repositories
-        SET is_primary = true, updated_at = NOW()
-        WHERE id = $1 AND chain_id = $2
-        RETURNING *
-        "#,
-    )
-    .bind(repository_id)
-    .bind(chain_id)
-    .fetch_one(pool)
-    .await
+    Ok(chain)
 }
 
-/// Get the primary repository for a chain.
-pub async fn get_chain_primary_repository(
-    pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Option<ChainRepository>, sqlx::Error> {
-    sqlx::query_as::<_, ChainRepository>(
-        r#"
-        SELECT *
-        FROM chain_repositories
-        WHERE chain_id = $1 AND is_primary = true
-        "#,
+/// Get a directive chain by ID.
+pub async fn get_directive_chain(pool: &PgPool, id: Uuid) -> Result<Option<DirectiveChain>, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveChain>(
+        "SELECT * FROM directive_chains WHERE id = $1"
     )
-    .bind(chain_id)
+    .bind(id)
     .fetch_optional(pool)
     .await
 }
 
-/// Get chain graph structure for visualization.
-pub async fn get_chain_graph(
-    pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Option<ChainGraphResponse>, sqlx::Error> {
-    let chain = get_chain(pool, chain_id).await?;
-
-    match chain {
-        Some(chain) => {
-            let contracts = list_chain_contracts(pool, chain_id).await?;
-
-            let nodes: Vec<ChainGraphNode> = contracts
-                .iter()
-                .map(|c| ChainGraphNode {
-                    id: c.chain_contract_id,
-                    contract_id: c.contract_id,
-                    name: c.contract_name.clone(),
-                    status: c.contract_status.clone(),
-                    phase: c.contract_phase.clone(),
-                    x: c.editor_x.unwrap_or(0.0),
-                    y: c.editor_y.unwrap_or(0.0),
-                })
-                .collect();
-
-            let mut edges: Vec<ChainGraphEdge> = Vec::new();
-            for contract in &contracts {
-                for dep_id in &contract.depends_on {
-                    // Find the chain_contract_id for this dependency
-                    if let Some(dep) = contracts.iter().find(|c| c.contract_id == *dep_id) {
-                        edges.push(ChainGraphEdge {
-                            from: dep.chain_contract_id,
-                            to: contract.chain_contract_id,
-                        });
-                    }
-                }
-            }
-
-            Ok(Some(ChainGraphResponse {
-                chain_id: chain.id,
-                chain_name: chain.name,
-                chain_status: chain.status,
-                nodes,
-                edges,
-            }))
-        }
-        None => Ok(None),
-    }
-}
-
-/// Record a chain event.
-pub async fn record_chain_event(
-    pool: &PgPool,
-    chain_id: Uuid,
-    event_type: &str,
-    contract_id: Option<Uuid>,
-    event_data: Option<serde_json::Value>,
-) -> Result<ChainEvent, sqlx::Error> {
-    sqlx::query_as::<_, ChainEvent>(
+/// Get the current chain for a directive.
+pub async fn get_current_chain(pool: &PgPool, directive_id: Uuid) -> Result<Option<DirectiveChain>, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveChain>(
         r#"
-        INSERT INTO chain_events (chain_id, event_type, contract_id, event_data)
-        VALUES ($1, $2, $3, $4)
-        RETURNING *
+        SELECT dc.* FROM directive_chains dc
+        JOIN directives d ON d.current_chain_id = dc.id
+        WHERE d.id = $1
         "#,
     )
-    .bind(chain_id)
-    .bind(event_type)
-    .bind(contract_id)
-    .bind(event_data)
-    .fetch_one(pool)
+    .bind(directive_id)
+    .fetch_optional(pool)
     .await
 }
 
-/// List chain events.
-pub async fn list_chain_events(
+/// Update chain status.
+pub async fn update_chain_status(
     pool: &PgPool,
     chain_id: Uuid,
-) -> Result<Vec<ChainEvent>, sqlx::Error> {
-    sqlx::query_as::<_, ChainEvent>(
-        r#"
-        SELECT *
-        FROM chain_events
-        WHERE chain_id = $1
-        ORDER BY created_at DESC
-        "#,
-    )
-    .bind(chain_id)
-    .fetch_all(pool)
-    .await
-}
-
-/// Increment chain loop iteration.
-pub async fn increment_chain_loop(pool: &PgPool, chain_id: Uuid) -> Result<Chain, sqlx::Error> {
-    sqlx::query_as::<_, Chain>(
+    status: &str,
+) -> Result<DirectiveChain, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveChain>(
         r#"
-        UPDATE chains
-        SET loop_current_iteration = COALESCE(loop_current_iteration, 0) + 1,
+        UPDATE directive_chains SET
+            status = $2,
+            started_at = CASE WHEN $2 = 'active' AND started_at IS NULL THEN NOW() ELSE started_at END,
+            completed_at = CASE WHEN $2 IN ('completed', 'failed', 'superseded') THEN NOW() ELSE completed_at END,
             updated_at = NOW()
         WHERE id = $1
         RETURNING *
         "#,
     )
     .bind(chain_id)
+    .bind(status)
     .fetch_one(pool)
     .await
 }
 
-/// Mark a chain as completed.
-pub async fn complete_chain(pool: &PgPool, chain_id: Uuid) -> Result<Chain, sqlx::Error> {
-    sqlx::query_as::<_, Chain>(
+/// Supersede a chain (mark as superseded and update directive).
+pub async fn supersede_chain(pool: &PgPool, chain_id: Uuid) -> Result<(), sqlx::Error> {
+    sqlx::query(
         r#"
-        UPDATE chains
-        SET status = 'completed',
-            updated_at = NOW()
+        UPDATE directive_chains SET status = 'superseded', completed_at = NOW(), updated_at = NOW()
         WHERE id = $1
-        RETURNING *
-        "#,
-    )
-    .bind(chain_id)
-    .fetch_one(pool)
-    .await
-}
-
-/// Get contracts in a chain that have no pending dependencies (ready to start).
-/// Returns contracts where all depends_on contracts are completed.
-pub async fn get_ready_chain_contracts(
-    pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Vec<ChainContractDetail>, sqlx::Error> {
-    sqlx::query_as::<_, ChainContractDetail>(
-        r#"
-        SELECT
-            cc.id as chain_contract_id,
-            cc.contract_id,
-            c.name as contract_name,
-            c.status as contract_status,
-            c.phase as contract_phase,
-            cc.depends_on,
-            cc.order_index,
-            cc.editor_x,
-            cc.editor_y
-        FROM chain_contracts cc
-        JOIN contracts c ON c.id = cc.contract_id
-        WHERE cc.chain_id = $1
-          AND c.status = 'active'
-          AND (
-            -- No dependencies
-            cc.depends_on IS NULL
-            OR array_length(cc.depends_on, 1) IS NULL
-            OR array_length(cc.depends_on, 1) = 0
-            -- Or all dependencies completed
-            OR NOT EXISTS (
-                SELECT 1
-                FROM unnest(cc.depends_on) AS dep_id
-                JOIN contracts dep ON dep.id = dep_id
-                WHERE dep.status != 'completed'
-            )
-          )
-        ORDER BY cc.order_index ASC
         "#,
     )
     .bind(chain_id)
-    .fetch_all(pool)
-    .await
-}
-
-/// Check if all contracts in a chain are completed.
-pub async fn is_chain_complete(pool: &PgPool, chain_id: Uuid) -> Result<bool, sqlx::Error> {
-    let result: (i64,) = sqlx::query_as(
-        r#"
-        SELECT COUNT(*)
-        FROM chain_contracts cc
-        JOIN contracts c ON c.id = cc.contract_id
-        WHERE cc.chain_id = $1
-          AND c.status != 'completed'
-        "#,
-    )
-    .bind(chain_id)
-    .fetch_one(pool)
+    .execute(pool)
     .await?;
-
-    Ok(result.0 == 0)
-}
-
-/// Get chain editor data for the GUI editor.
-pub async fn get_chain_editor_data(
-    pool: &PgPool,
-    chain_id: Uuid,
-    owner_id: Uuid,
-) -> Result<Option<ChainEditorData>, sqlx::Error> {
-    let chain = get_chain_for_owner(pool, chain_id, owner_id).await?;
-
-    match chain {
-        Some(chain) => {
-            let contracts = list_chain_contracts(pool, chain_id).await?;
-            let repositories = list_chain_repositories(pool, chain_id).await?;
-
-            // Build nodes
-            let nodes: Vec<ChainEditorNode> = contracts
-                .iter()
-                .map(|c| ChainEditorNode {
-                    id: c.contract_id.to_string(),
-                    x: c.editor_x.unwrap_or(0.0),
-                    y: c.editor_y.unwrap_or(0.0),
-                    contract: ChainEditorContract {
-                        name: c.contract_name.clone(),
-                        description: None, // Would need to join with full contract data
-                        contract_type: "simple".to_string(),
-                        phases: vec!["plan".to_string(), "execute".to_string()],
-                        tasks: vec![],
-                        deliverables: vec![],
-                    },
-                })
-                .collect();
-
-            // Build edges
-            let edges: Vec<ChainEditorEdge> = contracts
-                .iter()
-                .flat_map(|c| {
-                    c.depends_on.iter().map(move |dep_id| ChainEditorEdge {
-                        from: dep_id.to_string(),
-                        to: c.contract_id.to_string(),
-                    })
-                })
-                .collect();
-
-            Ok(Some(ChainEditorData {
-                id: Some(chain.id),
-                name: chain.name,
-                description: chain.description,
-                repositories,
-                loop_enabled: chain.loop_enabled,
-                loop_max_iterations: chain.loop_max_iterations,
-                loop_progress_check: chain.loop_progress_check,
-                nodes,
-                edges,
-            }))
-        }
-        None => Ok(None),
-    }
+    Ok(())
 }
 
 // =============================================================================
-// Chain Contract Definition Operations
+// Chain Step Operations
 // =============================================================================
 
-/// Create a new contract definition in a chain.
-pub async fn create_chain_contract_definition(
+/// Create a new step in a chain.
+pub async fn create_chain_step(
     pool: &PgPool,
     chain_id: Uuid,
-    req: AddContractDefinitionRequest,
-) -> Result<ChainContractDefinition, sqlx::Error> {
-    // Get the next order index
-    let max_order: Option<i32> = sqlx::query_scalar(
-        "SELECT MAX(order_index) FROM chain_contract_definitions WHERE chain_id = $1",
+    req: AddStepRequest,
+) -> Result<ChainStep, sqlx::Error> {
+    let step_type = req.step_type.unwrap_or_else(|| "execute".to_string());
+    let contract_type = req.contract_type.unwrap_or_else(|| "simple".to_string());
+    let phases = req.phases.unwrap_or_default();
+    let depends_on = req.depends_on.unwrap_or_default();
+    let requirement_ids = req.requirement_ids.unwrap_or_default();
+    let acceptance_criteria_ids = req.acceptance_criteria_ids.unwrap_or_default();
+    let verifier_config = req.verifier_config.unwrap_or(serde_json::json!({}));
+
+    // Get next order index
+    let order_index = sqlx::query_scalar::<_, i32>(
+        "SELECT COALESCE(MAX(order_index), 0) + 1 FROM chain_steps WHERE chain_id = $1"
     )
     .bind(chain_id)
     .fetch_one(pool)
     .await?;
 
-    let order_index = max_order.unwrap_or(-1) + 1;
-
-    // Convert tasks, deliverables, and validation to JSON
-    let tasks_json = req.tasks.as_ref().map(|t| serde_json::to_value(t).unwrap());
-    let deliverables_json = req
-        .deliverables
-        .as_ref()
-        .map(|d| serde_json::to_value(d).unwrap());
-    let validation_json = req
-        .validation
-        .as_ref()
-        .map(|v| serde_json::to_value(v).unwrap());
-    let depends_on_names: Vec<String> = req.depends_on.unwrap_or_default();
-
-    sqlx::query_as::<_, ChainContractDefinition>(
-        r#"
-        INSERT INTO chain_contract_definitions
-            (chain_id, name, description, contract_type, initial_phase, depends_on_names, tasks, deliverables, validation, editor_x, editor_y, order_index)
-        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+    let step = sqlx::query_as::<_, ChainStep>(
+        r#"
+        INSERT INTO chain_steps (
+            chain_id, name, description, step_type, contract_type,
+            initial_phase, task_plan, phases, depends_on, parallel_group,
+            requirement_ids, acceptance_criteria_ids, verifier_config,
+            editor_x, editor_y, order_index
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
         RETURNING *
         "#,
     )
     .bind(chain_id)
     .bind(&req.name)
     .bind(&req.description)
-    .bind(&req.contract_type)
+    .bind(&step_type)
+    .bind(&contract_type)
     .bind(&req.initial_phase)
-    .bind(&depends_on_names)
-    .bind(&tasks_json)
-    .bind(&deliverables_json)
-    .bind(&validation_json)
-    .bind(req.editor_x)
-    .bind(req.editor_y)
+    .bind(&req.task_plan)
+    .bind(&phases)
+    .bind(&depends_on)
+    .bind(&req.parallel_group)
+    .bind(&requirement_ids)
+    .bind(&acceptance_criteria_ids)
+    .bind(&verifier_config)
+    .bind(req.editor_x.unwrap_or(0.0))
+    .bind(req.editor_y.unwrap_or(0.0))
     .bind(order_index)
     .fetch_one(pool)
-    .await
-}
+    .await?;
 
-/// List all contract definitions in a chain.
-pub async fn list_chain_contract_definitions(
-    pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Vec<ChainContractDefinition>, sqlx::Error> {
-    sqlx::query_as::<_, ChainContractDefinition>(
-        r#"
-        SELECT * FROM chain_contract_definitions
-        WHERE chain_id = $1
-        ORDER BY order_index ASC
-        "#,
+    // Update chain total_steps count
+    sqlx::query(
+        "UPDATE directive_chains SET total_steps = total_steps + 1, updated_at = NOW() WHERE id = $1"
     )
     .bind(chain_id)
-    .fetch_all(pool)
-    .await
+    .execute(pool)
+    .await?;
+
+    Ok(step)
 }
 
-/// Get a specific contract definition.
-pub async fn get_chain_contract_definition(
-    pool: &PgPool,
-    definition_id: Uuid,
-) -> Result<Option<ChainContractDefinition>, sqlx::Error> {
-    sqlx::query_as::<_, ChainContractDefinition>(
-        "SELECT * FROM chain_contract_definitions WHERE id = $1",
+/// Get a chain step by ID.
+pub async fn get_chain_step(pool: &PgPool, id: Uuid) -> Result<Option<ChainStep>, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
+        "SELECT * FROM chain_steps WHERE id = $1"
     )
-    .bind(definition_id)
+    .bind(id)
     .fetch_optional(pool)
     .await
 }
 
-/// Update a contract definition.
-pub async fn update_chain_contract_definition(
-    pool: &PgPool,
-    definition_id: Uuid,
-    req: UpdateContractDefinitionRequest,
-) -> Result<ChainContractDefinition, sqlx::Error> {
-    let tasks_json = req.tasks.as_ref().map(|t| serde_json::to_value(t).unwrap());
-    let deliverables_json = req
-        .deliverables
-        .as_ref()
-        .map(|d| serde_json::to_value(d).unwrap());
-    let validation_json = req
-        .validation
-        .as_ref()
-        .map(|v| serde_json::to_value(v).unwrap());
+/// List all steps in a chain.
+pub async fn list_chain_steps(pool: &PgPool, chain_id: Uuid) -> Result<Vec<ChainStep>, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
+        "SELECT * FROM chain_steps WHERE chain_id = $1 ORDER BY order_index"
+    )
+    .bind(chain_id)
+    .fetch_all(pool)
+    .await
+}
 
-    sqlx::query_as::<_, ChainContractDefinition>(
+/// Update a chain step.
+pub async fn update_chain_step(
+    pool: &PgPool,
+    step_id: Uuid,
+    req: UpdateStepRequest,
+) -> Result<ChainStep, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
         r#"
-        UPDATE chain_contract_definitions SET
+        UPDATE chain_steps SET
             name = COALESCE($2, name),
             description = COALESCE($3, description),
-            contract_type = COALESCE($4, contract_type),
-            initial_phase = COALESCE($5, initial_phase),
-            depends_on_names = COALESCE($6, depends_on_names),
-            tasks = COALESCE($7, tasks),
-            deliverables = COALESCE($8, deliverables),
-            validation = COALESCE($9, validation),
-            editor_x = COALESCE($10, editor_x),
-            editor_y = COALESCE($11, editor_y)
+            task_plan = COALESCE($4, task_plan),
+            depends_on = COALESCE($5, depends_on),
+            requirement_ids = COALESCE($6, requirement_ids),
+            acceptance_criteria_ids = COALESCE($7, acceptance_criteria_ids),
+            verifier_config = COALESCE($8, verifier_config),
+            editor_x = COALESCE($9, editor_x),
+            editor_y = COALESCE($10, editor_y)
         WHERE id = $1
         RETURNING *
         "#,
     )
-    .bind(definition_id)
+    .bind(step_id)
     .bind(&req.name)
     .bind(&req.description)
-    .bind(&req.contract_type)
-    .bind(&req.initial_phase)
+    .bind(&req.task_plan)
     .bind(&req.depends_on)
-    .bind(&tasks_json)
-    .bind(&deliverables_json)
-    .bind(&validation_json)
+    .bind(&req.requirement_ids)
+    .bind(&req.acceptance_criteria_ids)
+    .bind(&req.verifier_config)
     .bind(req.editor_x)
     .bind(req.editor_y)
     .fetch_one(pool)
     .await
 }
 
-/// Delete a contract definition.
-pub async fn delete_chain_contract_definition(
-    pool: &PgPool,
-    definition_id: Uuid,
-) -> Result<bool, sqlx::Error> {
-    let result = sqlx::query("DELETE FROM chain_contract_definitions WHERE id = $1")
-        .bind(definition_id)
+/// Delete a chain step.
+pub async fn delete_chain_step(pool: &PgPool, step_id: Uuid) -> Result<bool, sqlx::Error> {
+    // Get chain_id first for updating count
+    let chain_id = sqlx::query_scalar::<_, Uuid>(
+        "SELECT chain_id FROM chain_steps WHERE id = $1"
+    )
+    .bind(step_id)
+    .fetch_optional(pool)
+    .await?;
+
+    let result = sqlx::query("DELETE FROM chain_steps WHERE id = $1")
+        .bind(step_id)
         .execute(pool)
         .await?;
+
+    // Update chain total_steps count
+    if let Some(cid) = chain_id {
+        sqlx::query(
+            "UPDATE directive_chains SET total_steps = total_steps - 1, updated_at = NOW() WHERE id = $1"
+        )
+        .bind(cid)
+        .execute(pool)
+        .await?;
+    }
+
     Ok(result.rows_affected() > 0)
 }
 
-/// Get definitions that are ready to be instantiated (all dependencies are satisfied).
-/// A definition is ready if all definitions it depends on have been instantiated as contracts
-/// and those contracts have completed.
-pub async fn get_ready_definitions(
-    pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Vec<ChainContractDefinition>, sqlx::Error> {
-    sqlx::query_as::<_, ChainContractDefinition>(
-        r#"
-        SELECT d.*
-        FROM chain_contract_definitions d
-        WHERE d.chain_id = $1
-        -- Not already instantiated
-        AND NOT EXISTS (
-            SELECT 1 FROM chain_contracts cc
-            WHERE cc.definition_id = d.id
-        )
-        -- All dependencies satisfied (either no deps, or all deps have completed contracts)
-        AND (
-            cardinality(d.depends_on_names) = 0
-            OR NOT EXISTS (
-                SELECT 1 FROM unnest(d.depends_on_names) AS dep_name
-                WHERE NOT EXISTS (
-                    SELECT 1 FROM chain_contract_definitions dep_def
-                    JOIN chain_contracts cc ON cc.definition_id = dep_def.id
-                    JOIN contracts c ON c.id = cc.contract_id
-                    WHERE dep_def.chain_id = d.chain_id
-                    AND dep_def.name = dep_name
-                    AND c.status = 'completed'
-                )
-            )
-        )
-        ORDER BY d.order_index ASC
+/// Find steps that are ready to execute (all dependencies met, status=pending).
+pub async fn find_ready_steps(pool: &PgPool, chain_id: Uuid) -> Result<Vec<ChainStep>, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
+        r#"
+        SELECT s.* FROM chain_steps s
+        WHERE s.chain_id = $1
+          AND s.status = 'pending'
+          AND NOT EXISTS (
+              SELECT 1 FROM chain_steps dep
+              WHERE dep.id = ANY(s.depends_on)
+                AND dep.status NOT IN ('passed', 'skipped')
+          )
+        ORDER BY s.order_index
         "#,
     )
     .bind(chain_id)
@@ -5772,909 +5533,500 @@ pub async fn get_ready_definitions(
     .await
 }
 
-/// Get the definition graph for visualization.
-pub async fn get_chain_definition_graph(
+/// Update step status.
+pub async fn update_step_status(
     pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Option<ChainDefinitionGraphResponse>, sqlx::Error> {
-    let chain = sqlx::query_as::<_, Chain>("SELECT * FROM chains WHERE id = $1")
-        .bind(chain_id)
-        .fetch_optional(pool)
-        .await?;
-
-    let Some(chain) = chain else {
-        return Ok(None);
-    };
-
-    let definitions = list_chain_contract_definitions(pool, chain_id).await?;
-
-    // Get instantiated contracts for each definition
-    let chain_contracts = list_chain_contracts(pool, chain_id).await?;
-    let instantiated: std::collections::HashMap<Uuid, &ChainContractDetail> = chain_contracts
-        .iter()
-        .filter_map(|cc| {
-            // Find definition_id from cc - we need to query this
-            // For now, match by name
-            definitions
-                .iter()
-                .find(|d| d.name == cc.contract_name)
-                .map(|d| (d.id, cc))
-        })
-        .collect();
-
-    let nodes: Vec<ChainDefinitionGraphNode> = definitions
-        .iter()
-        .map(|d| {
-            let cc = instantiated.get(&d.id);
-            ChainDefinitionGraphNode {
-                id: d.id,
-                name: d.name.clone(),
-                contract_type: d.contract_type.clone(),
-                x: d.editor_x.unwrap_or(0.0),
-                y: d.editor_y.unwrap_or(0.0),
-                is_instantiated: cc.is_some(),
-                contract_id: cc.map(|c| c.contract_id),
-                contract_status: cc.map(|c| c.contract_status.clone()),
-            }
-        })
-        .collect();
-
-    // Build edges from depends_on_names
-    let name_to_id: std::collections::HashMap<&str, Uuid> =
-        definitions.iter().map(|d| (d.name.as_str(), d.id)).collect();
-
-    let edges: Vec<ChainGraphEdge> = definitions
-        .iter()
-        .flat_map(|d| {
-            let target_id = d.id;
-            let name_to_id = &name_to_id;
-            d.depends_on_names.iter().filter_map(move |dep_name| {
-                name_to_id
-                    .get(dep_name.as_str())
-                    .map(|&from_id| ChainGraphEdge { from: from_id, to: target_id })
-            })
-        })
-        .collect();
-
-    Ok(Some(ChainDefinitionGraphResponse {
-        chain_id: chain.id,
-        chain_name: chain.name,
-        chain_status: chain.status,
-        nodes,
-        edges,
-    }))
-}
-
-/// Update chain status.
-pub async fn update_chain_status(
-    pool: &PgPool,
-    chain_id: Uuid,
+    step_id: Uuid,
     status: &str,
-) -> Result<(), sqlx::Error> {
-    sqlx::query("UPDATE chains SET status = $2, updated_at = NOW() WHERE id = $1")
-        .bind(chain_id)
-        .bind(status)
-        .execute(pool)
-        .await?;
-    Ok(())
-}
-
-// =============================================================================
-// Chain Progression
-// =============================================================================
-
-/// Result of chain progression check
-#[derive(Debug)]
-pub struct ChainProgressionResult {
-    /// Contracts created from ready definitions
-    pub contracts_created: Vec<Uuid>,
-    /// Whether all definitions are instantiated and completed (chain is done)
-    pub chain_completed: bool,
-}
-
-/// Progress a chain by creating contracts from ready definitions.
-///
-/// This is called when a contract in the chain completes. It:
-/// 1. Finds definitions whose dependencies are all satisfied (completed)
-/// 2. Creates contracts from those definitions
-/// 3. Links them to the chain
-/// 4. Checks if chain is complete (all definitions instantiated and completed)
-pub async fn progress_chain(
-    pool: &PgPool,
-    chain_id: Uuid,
-    owner_id: Uuid,
-) -> Result<ChainProgressionResult, sqlx::Error> {
-    let mut contracts_created = Vec::new();
-
-    // Get all definitions for this chain
-    let definitions = list_chain_contract_definitions(pool, chain_id).await?;
-    if definitions.is_empty() {
-        return Ok(ChainProgressionResult {
-            contracts_created: vec![],
-            chain_completed: true,
-        });
-    }
-
-    // Get existing chain contracts to know what's already instantiated
-    let chain_contracts = list_chain_contracts(pool, chain_id).await?;
-
-    // Build a map of definition name -> instantiated contract status
-    let instantiated: std::collections::HashMap<String, Option<String>> = chain_contracts
-        .iter()
-        .map(|cc| (cc.contract_name.clone(), Some(cc.contract_status.clone())))
-        .collect();
-
-    // Find definitions that are ready to be instantiated:
-    // - Not yet instantiated
-    // - All dependencies are instantiated AND completed
-    for def in &definitions {
-        // Skip if already instantiated
-        if instantiated.contains_key(&def.name) {
-            continue;
-        }
-
-        // Check if all dependencies are completed
-        let deps_satisfied = def.depends_on_names.iter().all(|dep_name| {
-            instantiated
-                .get(dep_name)
-                .map(|status| status.as_deref() == Some("completed"))
-                .unwrap_or(false)
-        });
-
-        // Root definitions (no dependencies) are always ready
-        let is_root = def.depends_on_names.is_empty();
-
-        if is_root || deps_satisfied {
-            // Create contract from definition
-            match create_contract_from_definition(pool, chain_id, owner_id, def).await {
-                Ok(contract_id) => {
-                    contracts_created.push(contract_id);
-                    tracing::info!(
-                        chain_id = %chain_id,
-                        definition_name = %def.name,
-                        contract_id = %contract_id,
-                        "Created contract from chain definition"
-                    );
-                }
-                Err(e) => {
-                    tracing::error!(
-                        chain_id = %chain_id,
-                        definition_name = %def.name,
-                        error = %e,
-                        "Failed to create contract from chain definition"
-                    );
-                }
-            }
-        }
-    }
-
-    // Check if chain is complete (all definitions instantiated and completed)
-    let updated_contracts = list_chain_contracts(pool, chain_id).await?;
-    let all_instantiated = definitions.len() == updated_contracts.len();
-    let all_completed = updated_contracts
-        .iter()
-        .all(|cc| cc.contract_status == "completed");
-    let chain_completed = all_instantiated && all_completed;
-
-    if chain_completed {
-        update_chain_status(pool, chain_id, "completed").await?;
-        tracing::info!(chain_id = %chain_id, "Chain completed - all contracts done");
-    }
-
-    Ok(ChainProgressionResult {
-        contracts_created,
-        chain_completed,
-    })
-}
-
-/// Task definition parsed from JSON (matches chain YAML format)
-#[derive(Debug, Clone, serde::Deserialize)]
-struct ChainTaskDef {
-    name: String,
-    plan: String,
-}
-
-/// Validation config parsed from definition JSON
-#[derive(Debug, Clone, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct ValidationConfig {
-    #[serde(default)]
-    check_deliverables: bool,
-    #[serde(default)]
-    run_tests: bool,
-    check_content: Option<String>,
-    #[serde(default = "default_on_failure_str")]
-    on_failure: String,
-    #[serde(default = "default_max_retries_val")]
-    max_retries: i32,
-}
-
-fn default_on_failure_str() -> String {
-    "block".to_string()
-}
-
-fn default_max_retries_val() -> i32 {
-    3
-}
-
-/// Generate a validation plan for a checkpoint contract.
-fn generate_checkpoint_plan(
-    def: &ChainContractDefinition,
-    upstream_contracts: &[&ChainContractDetail],
-    validation: &ValidationConfig,
-) -> String {
-    let upstream_names: Vec<&str> = upstream_contracts.iter().map(|c| c.contract_name.as_str()).collect();
-
-    let mut plan = format!(
-        r#"# Checkpoint Validation: {}
-
-You are validating the outputs of upstream contracts before allowing downstream work to proceed.
-
-## Upstream Contracts to Validate
-{}
-
-"#,
-        def.name,
-        upstream_names.iter().map(|n| format!("- {}", n)).collect::<Vec<_>>().join("\n")
-    );
-
-    // Add deliverables check section
-    if validation.check_deliverables {
-        plan.push_str(r#"## Deliverables Check
-Verify that all required deliverables from upstream contracts exist and are properly completed.
-
-Use the makima CLI to check contract status:
-```bash
-makima contract status <contract_id>
-```
-
-For each upstream contract, verify:
-1. Contract status is "completed"
-2. All required deliverables are marked as complete
-3. Deliverable content exists and is not empty
-
-"#);
-    }
-
-    // Add tests check section
-    if validation.run_tests {
-        plan.push_str(r#"## Tests Check
-Run the test suite to verify the codebase is in a good state.
-
-```bash
-# Run tests appropriate for the project type
-npm test       # for Node.js projects
-cargo test     # for Rust projects
-pytest         # for Python projects
-go test ./...  # for Go projects
-```
-
-Verify:
-1. All tests pass
-2. No new test failures introduced
-3. Test coverage is acceptable
-
-"#);
-    }
-
-    // Add custom content check section
-    if let Some(content_check) = &validation.check_content {
-        plan.push_str(&format!(r#"## Custom Validation Criteria
-{}
-
-"#, content_check));
-    }
-
-    // Add validation result section
-    plan.push_str(&format!(r#"## Reporting Results
-
-After completing all validation checks, you must report the result:
-
-**If ALL checks pass:**
-Mark this checkpoint contract as completed using:
-```bash
-makima supervisor complete
-```
-
-**If ANY check fails (on_failure: "{}"):**
-"#, validation.on_failure));
-
-    match validation.on_failure.as_str() {
-        "block" => plan.push_str(r#"
-- Document the failure reason clearly
-- Do NOT mark the contract as complete
-- The chain will be blocked until issues are resolved manually
-"#),
-        "retry" => plan.push_str(&format!(r#"
-- Document the failure reason
-- Request retry of the failed upstream contract (max {} retries)
-- Use: `makima supervisor ask "Upstream validation failed. Retry?" --choices "Yes,No"`
-"#, validation.max_retries)),
-        "warn" => plan.push_str(r#"
-- Document the warning/issue found
-- Mark the contract as complete anyway (downstream will proceed)
-- Log the warning for visibility
-"#),
-        _ => plan.push_str(r#"
-- Document the failure reason
-- Do NOT mark the contract as complete
-"#),
-    }
-
-    plan.push_str(r#"
-## Begin Validation
-
-Start by checking the status of each upstream contract, then proceed with the validation criteria above.
-"#);
-
-    plan
-}
-
-/// Create a contract from a chain definition.
-async fn create_contract_from_definition(
-    pool: &PgPool,
-    chain_id: Uuid,
-    owner_id: Uuid,
-    def: &ChainContractDefinition,
-) -> Result<Uuid, sqlx::Error> {
-    // Get the existing contracts to find dependency info
-    let existing_contracts = list_chain_contracts(pool, chain_id).await?;
-    let name_to_contract: std::collections::HashMap<&str, &ChainContractDetail> = existing_contracts
-        .iter()
-        .map(|cc| (cc.contract_name.as_str(), cc))
-        .collect();
-
-    // Resolve dependency names to contract details
-    let upstream_contracts: Vec<&ChainContractDetail> = def
-        .depends_on_names
-        .iter()
-        .filter_map(|name| name_to_contract.get(name.as_str()).copied())
-        .collect();
-
-    // Create the contract request with basic fields
-    let req = CreateContractRequest {
-        name: def.name.clone(),
-        description: def.description.clone(),
-        contract_type: Some(def.contract_type.clone()),
-        initial_phase: def.initial_phase.clone(),
-        template_id: None,
-        autonomous_loop: None,
-        phase_guard: None,
-        local_only: None,
-        auto_merge_local: None,
-    };
-
-    // Create the contract
-    let contract = create_contract_for_owner(pool, owner_id, req).await?;
-
-    // For checkpoint contracts, generate a validation plan
-    if def.contract_type == "checkpoint" {
-        // Parse validation config
-        let validation: ValidationConfig = def
-            .validation
-            .as_ref()
-            .and_then(|v| serde_json::from_value(v.clone()).ok())
-            .unwrap_or(ValidationConfig {
-                check_deliverables: true,
-                run_tests: false,
-                check_content: None,
-                on_failure: default_on_failure_str(),
-                max_retries: default_max_retries_val(),
-            });
-
-        // Generate validation plan
-        let validation_plan = generate_checkpoint_plan(def, &upstream_contracts, &validation);
-
-        // Create a supervisor task with the validation plan
-        let task_req = CreateTaskRequest {
-            contract_id: Some(contract.id),
-            name: format!("Validate: {}", def.name),
-            description: Some("Checkpoint validation task".to_string()),
-            plan: validation_plan,
-            parent_task_id: None,
-            is_supervisor: true, // Checkpoint uses supervisor task for validation
-            priority: 0,
-            repository_url: None,
-            base_branch: None,
-            target_branch: None,
-            merge_mode: None,
-            target_repo_path: None,
-            completion_action: None,
-            continue_from_task_id: None,
-            copy_files: None,
-            checkpoint_sha: None,
-            branched_from_task_id: None,
-            conversation_history: None,
-            supervisor_worktree_task_id: None,
-        };
-
-        if let Err(e) = create_task_for_owner(pool, owner_id, task_req).await {
-            tracing::warn!(
-                contract_id = %contract.id,
-                error = %e,
-                "Failed to create validation task for checkpoint contract"
-            );
-        }
+) -> Result<ChainStep, sqlx::Error> {
+    let step = sqlx::query_as::<_, ChainStep>(
+        r#"
+        UPDATE chain_steps SET
+            status = $2,
+            started_at = CASE WHEN $2 = 'running' AND started_at IS NULL THEN NOW() ELSE started_at END,
+            completed_at = CASE WHEN $2 IN ('passed', 'failed', 'skipped') THEN NOW() ELSE completed_at END
+        WHERE id = $1
+        RETURNING *
+        "#,
+    )
+    .bind(step_id)
+    .bind(status)
+    .fetch_one(pool)
+    .await?;
 
-        // Set initial validation status
+    // Update chain completed_steps and failed_steps counts
+    if status == "passed" || status == "skipped" {
         sqlx::query(
-            "UPDATE chain_contracts SET validation_status = 'pending' WHERE chain_id = $1 AND contract_id = $2",
+            "UPDATE directive_chains SET completed_steps = completed_steps + 1, updated_at = NOW() WHERE id = $1"
         )
-        .bind(chain_id)
-        .bind(contract.id)
+        .bind(step.chain_id)
         .execute(pool)
         .await?;
-    } else {
-        // Parse and create tasks from definition for regular contracts
-        if let Some(tasks_json) = &def.tasks {
-            if let Ok(tasks) = serde_json::from_value::<Vec<ChainTaskDef>>(tasks_json.clone()) {
-                for task_def in tasks {
-                    let task_req = CreateTaskRequest {
-                        contract_id: Some(contract.id),
-                        name: task_def.name,
-                        description: None,
-                        plan: task_def.plan,
-                        parent_task_id: None,
-                        is_supervisor: false,
-                        priority: 0,
-                        repository_url: None,
-                        base_branch: None,
-                        target_branch: None,
-                        merge_mode: None,
-                        target_repo_path: None,
-                        completion_action: None,
-                        continue_from_task_id: None,
-                        copy_files: None,
-                        checkpoint_sha: None,
-                        branched_from_task_id: None,
-                        conversation_history: None,
-                        supervisor_worktree_task_id: None,
-                    };
-                    if let Err(e) = create_task_for_owner(pool, owner_id, task_req).await {
-                        tracing::warn!(
-                            contract_id = %contract.id,
-                            error = %e,
-                            "Failed to create task from chain definition"
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    // Resolve dependency names to contract IDs
-    let depends_on: Vec<Uuid> = upstream_contracts.iter().map(|c| c.contract_id).collect();
-
-    // Link contract to chain
-    add_contract_to_chain(
-        pool,
-        chain_id,
-        contract.id,
-        depends_on,
-        def.order_index,
-        def.editor_x,
-        def.editor_y,
-    )
-    .await?;
-
-    // Update chain_contracts with definition_id link
-    sqlx::query(
-        "UPDATE chain_contracts SET definition_id = $1 WHERE chain_id = $2 AND contract_id = $3",
-    )
-    .bind(def.id)
-    .bind(chain_id)
-    .bind(contract.id)
-    .execute(pool)
-    .await?;
-
-    // Copy repositories from chain to contract
-    let chain_repos = list_chain_repositories(pool, chain_id).await.unwrap_or_default();
-    for repo in chain_repos {
-        if let Some(url) = &repo.repository_url {
-            // Remote repository
-            if let Err(e) = add_remote_repository(pool, contract.id, &repo.name, url, repo.is_primary).await {
-                tracing::warn!(
-                    contract_id = %contract.id,
-                    repo_name = %repo.name,
-                    error = %e,
-                    "Failed to copy repository from chain to contract"
-                );
-            }
-        } else if let Some(path) = &repo.local_path {
-            // Local repository
-            if let Err(e) = add_local_repository(pool, contract.id, &repo.name, path, repo.is_primary).await {
-                tracing::warn!(
-                    contract_id = %contract.id,
-                    repo_name = %repo.name,
-                    error = %e,
-                    "Failed to copy local repository from chain to contract"
-                );
-            }
-        }
-    }
-
-    // Activate the contract so it can start
-    sqlx::query("UPDATE contracts SET status = 'active' WHERE id = $1")
-        .bind(contract.id)
+    } else if status == "failed" {
+        sqlx::query(
+            "UPDATE directive_chains SET failed_steps = failed_steps + 1, updated_at = NOW() WHERE id = $1"
+        )
+        .bind(step.chain_id)
         .execute(pool)
         .await?;
+    }
 
-    tracing::info!(
-        contract_id = %contract.id,
-        contract_name = %def.name,
-        chain_id = %chain_id,
-        "Contract created and activated from chain definition"
-    );
-
-    Ok(contract.id)
+    Ok(step)
 }
 
-// =============================================================================
-// Chain Directives
-// =============================================================================
-
-/// Create a directive for a chain.
-pub async fn create_chain_directive(
+/// Link a step to a contract.
+pub async fn update_step_contract(
     pool: &PgPool,
-    chain_id: Uuid,
-    req: CreateChainDirectiveRequest,
-) -> Result<ChainDirective, sqlx::Error> {
-    let requirements = serde_json::to_value(&req.requirements.unwrap_or_default())
-        .unwrap_or(serde_json::json!([]));
-    let acceptance_criteria = serde_json::to_value(&req.acceptance_criteria.unwrap_or_default())
-        .unwrap_or(serde_json::json!([]));
-    let constraints =
-        serde_json::to_value(&req.constraints.unwrap_or_default()).unwrap_or(serde_json::json!([]));
-    let external_dependencies =
-        serde_json::to_value(&req.external_dependencies.unwrap_or_default())
-            .unwrap_or(serde_json::json!([]));
-    let source_type = req.source_type.unwrap_or_else(|| "llm_generated".to_string());
-
-    sqlx::query_as::<_, ChainDirective>(
-        r#"
-        INSERT INTO chain_directives (chain_id, requirements, acceptance_criteria, constraints, external_dependencies, source_type)
-        VALUES ($1, $2, $3, $4, $5, $6)
+    step_id: Uuid,
+    contract_id: Uuid,
+    supervisor_task_id: Option<Uuid>,
+) -> Result<ChainStep, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
+        r#"
+        UPDATE chain_steps SET contract_id = $2, supervisor_task_id = $3
+        WHERE id = $1
         RETURNING *
         "#,
     )
-    .bind(chain_id)
-    .bind(&requirements)
-    .bind(&acceptance_criteria)
-    .bind(&constraints)
-    .bind(&external_dependencies)
-    .bind(&source_type)
+    .bind(step_id)
+    .bind(contract_id)
+    .bind(supervisor_task_id)
     .fetch_one(pool)
     .await
 }
 
-/// Get the directive for a chain.
-pub async fn get_chain_directive(
+/// Update step confidence score and level.
+pub async fn update_step_confidence(
     pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Option<ChainDirective>, sqlx::Error> {
-    sqlx::query_as::<_, ChainDirective>(
+    step_id: Uuid,
+    score: f64,
+    level: &str,
+    evaluation_id: Uuid,
+) -> Result<ChainStep, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
         r#"
-        SELECT *
-        FROM chain_directives
-        WHERE chain_id = $1
+        UPDATE chain_steps SET
+            confidence_score = $2,
+            confidence_level = $3,
+            last_evaluation_id = $4,
+            evaluation_count = evaluation_count + 1
+        WHERE id = $1
+        RETURNING *
         "#,
     )
-    .bind(chain_id)
-    .fetch_optional(pool)
+    .bind(step_id)
+    .bind(score)
+    .bind(level)
+    .bind(evaluation_id)
+    .fetch_one(pool)
     .await
 }
 
-/// Update a chain directive.
-pub async fn update_chain_directive(
-    pool: &PgPool,
-    chain_id: Uuid,
-    req: CreateChainDirectiveRequest,
-) -> Result<ChainDirective, sqlx::Error> {
-    let requirements = req
-        .requirements
-        .map(|r| serde_json::to_value(&r).unwrap_or(serde_json::json!([])));
-    let acceptance_criteria = req
-        .acceptance_criteria
-        .map(|ac| serde_json::to_value(&ac).unwrap_or(serde_json::json!([])));
-    let constraints = req
-        .constraints
-        .map(|c| serde_json::to_value(&c).unwrap_or(serde_json::json!([])));
-    let external_dependencies = req
-        .external_dependencies
-        .map(|ed| serde_json::to_value(&ed).unwrap_or(serde_json::json!([])));
-
-    sqlx::query_as::<_, ChainDirective>(
-        r#"
-        UPDATE chain_directives SET
-            requirements = COALESCE($2, requirements),
-            acceptance_criteria = COALESCE($3, acceptance_criteria),
-            constraints = COALESCE($4, constraints),
-            external_dependencies = COALESCE($5, external_dependencies),
-            source_type = COALESCE($6, source_type),
-            version = version + 1,
-            updated_at = NOW()
-        WHERE chain_id = $1
+/// Increment step rework count.
+pub async fn increment_step_rework_count(pool: &PgPool, step_id: Uuid) -> Result<ChainStep, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
+        r#"
+        UPDATE chain_steps SET rework_count = rework_count + 1, status = 'rework'
+        WHERE id = $1
         RETURNING *
         "#,
     )
-    .bind(chain_id)
-    .bind(&requirements)
-    .bind(&acceptance_criteria)
-    .bind(&constraints)
-    .bind(&external_dependencies)
-    .bind(&req.source_type)
+    .bind(step_id)
     .fetch_one(pool)
     .await
 }
 
-/// Delete a chain directive.
-pub async fn delete_chain_directive(pool: &PgPool, chain_id: Uuid) -> Result<bool, sqlx::Error> {
-    let result = sqlx::query("DELETE FROM chain_directives WHERE chain_id = $1")
-        .bind(chain_id)
-        .execute(pool)
-        .await?;
-    Ok(result.rows_affected() > 0)
-}
-
-/// Get directive traceability (requirement -> contract mapping).
-pub async fn get_directive_traceability(
+/// Get chain graph for visualization.
+pub async fn get_chain_graph(
     pool: &PgPool,
     chain_id: Uuid,
-) -> Result<DirectiveTraceabilityResponse, sqlx::Error> {
-    // Get the directive
-    let directive = get_chain_directive(pool, chain_id).await?;
-
-    // Get all contract definitions with their requirement mappings
-    let definitions = list_chain_contract_definitions(pool, chain_id).await?;
-
-    // Parse requirements from directive
-    let requirements: Vec<super::models::DirectiveRequirement> = directive
-        .as_ref()
-        .and_then(|d| serde_json::from_value(d.requirements.clone()).ok())
-        .unwrap_or_default();
-
-    // Build traceability entries
-    let mut entries: Vec<TraceabilityEntry> = Vec::new();
-    let mut covered_requirements: std::collections::HashSet<String> =
-        std::collections::HashSet::new();
-
-    for req in &requirements {
-        let mut contract_def_ids: Vec<Uuid> = Vec::new();
-        let mut contract_def_names: Vec<String> = Vec::new();
-
-        for def in &definitions {
-            if def.requirement_ids.contains(&req.id) {
-                contract_def_ids.push(def.id);
-                contract_def_names.push(def.name.clone());
-                covered_requirements.insert(req.id.clone());
-            }
+) -> Result<DirectiveChainGraphResponse, sqlx::Error> {
+    let chain = get_directive_chain(pool, chain_id).await?
+        .ok_or_else(|| sqlx::Error::RowNotFound)?;
+
+    let steps = list_chain_steps(pool, chain_id).await?;
+
+    let nodes: Vec<DirectiveChainGraphNode> = steps.iter().map(|s| {
+        DirectiveChainGraphNode {
+            id: s.id,
+            name: s.name.clone(),
+            step_type: s.step_type.clone(),
+            status: s.status.clone(),
+            confidence_score: s.confidence_score,
+            confidence_level: s.confidence_level.clone(),
+            contract_id: s.contract_id,
+            editor_x: s.editor_x,
+            editor_y: s.editor_y,
+        }
+    }).collect();
+
+    let mut edges = Vec::new();
+    for step in &steps {
+        for dep_id in &step.depends_on {
+            edges.push(DirectiveChainGraphEdge {
+                source: *dep_id,
+                target: step.id,
+            });
         }
-
-        // Get acceptance criteria for this requirement
-        let acceptance_criteria: Vec<super::models::DirectiveAcceptanceCriterion> = directive
-            .as_ref()
-            .and_then(|d| serde_json::from_value(d.acceptance_criteria.clone()).ok())
-            .unwrap_or_default();
-
-        let ac_ids: Vec<String> = acceptance_criteria
-            .iter()
-            .filter(|ac| ac.requirement_ids.contains(&req.id))
-            .map(|ac| ac.id.clone())
-            .collect();
-
-        entries.push(TraceabilityEntry {
-            requirement_id: req.id.clone(),
-            requirement_title: req.title.clone(),
-            contract_definition_ids: contract_def_ids,
-            contract_definition_names: contract_def_names,
-            acceptance_criteria_ids: ac_ids,
-        });
     }
 
-    // Find uncovered requirements
-    let uncovered: Vec<String> = requirements
-        .iter()
-        .filter(|r| !covered_requirements.contains(&r.id))
-        .map(|r| r.id.clone())
-        .collect();
-
-    Ok(DirectiveTraceabilityResponse {
+    Ok(DirectiveChainGraphResponse {
         chain_id,
-        entries,
-        uncovered_requirements: uncovered,
+        directive_id: chain.directive_id,
+        nodes,
+        edges,
     })
 }
 
 // =============================================================================
-// Contract Evaluations
+// Directive Evaluation Operations
 // =============================================================================
 
-/// Create a contract evaluation record.
-pub async fn create_contract_evaluation(
+/// Create a directive evaluation.
+pub async fn create_directive_evaluation(
     pool: &PgPool,
-    req: CreateContractEvaluationRequest,
-) -> Result<ContractEvaluation, sqlx::Error> {
-    let criteria_results = serde_json::to_value(&req.criteria_results).unwrap_or(serde_json::json!([]));
+    directive_id: Uuid,
+    chain_id: Option<Uuid>,
+    step_id: Option<Uuid>,
+    contract_id: Option<Uuid>,
+    evaluation_type: &str,
+    evaluator: Option<&str>,
+    passed: bool,
+    overall_score: Option<f64>,
+    confidence_level: Option<&str>,
+    programmatic_results: serde_json::Value,
+    llm_results: serde_json::Value,
+    criteria_results: serde_json::Value,
+    summary_feedback: &str,
+    rework_instructions: Option<&str>,
+) -> Result<DirectiveEvaluation, sqlx::Error> {
+    // Get next evaluation number for this step/directive
+    let evaluation_number = if let Some(sid) = step_id {
+        sqlx::query_scalar::<_, i32>(
+            "SELECT COALESCE(MAX(evaluation_number), 0) + 1 FROM directive_evaluations WHERE step_id = $1"
+        )
+        .bind(sid)
+        .fetch_one(pool)
+        .await?
+    } else {
+        sqlx::query_scalar::<_, i32>(
+            "SELECT COALESCE(MAX(evaluation_number), 0) + 1 FROM directive_evaluations WHERE directive_id = $1 AND step_id IS NULL"
+        )
+        .bind(directive_id)
+        .fetch_one(pool)
+        .await?
+    };
 
-    sqlx::query_as::<_, ContractEvaluation>(
+    sqlx::query_as::<_, DirectiveEvaluation>(
         r#"
-        INSERT INTO contract_evaluations (
-            contract_id, chain_id, chain_contract_id,
-            evaluator_model, passed, overall_score,
-            criteria_results, summary_feedback, rework_instructions,
+        INSERT INTO directive_evaluations (
+            directive_id, chain_id, step_id, contract_id,
+            evaluation_type, evaluation_number, evaluator,
+            passed, overall_score, confidence_level,
+            programmatic_results, llm_results, criteria_results,
+            summary_feedback, rework_instructions,
             completed_at
         )
-        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW())
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, NOW())
         RETURNING *
         "#,
     )
-    .bind(req.contract_id)
-    .bind(req.chain_id)
-    .bind(req.chain_contract_id)
-    .bind(&req.evaluator_model)
-    .bind(req.passed)
-    .bind(req.overall_score)
+    .bind(directive_id)
+    .bind(chain_id)
+    .bind(step_id)
+    .bind(contract_id)
+    .bind(evaluation_type)
+    .bind(evaluation_number)
+    .bind(evaluator)
+    .bind(passed)
+    .bind(overall_score)
+    .bind(confidence_level)
+    .bind(&programmatic_results)
+    .bind(&llm_results)
     .bind(&criteria_results)
-    .bind(&req.summary_feedback)
-    .bind(&req.rework_instructions)
+    .bind(summary_feedback)
+    .bind(rework_instructions)
     .fetch_one(pool)
     .await
 }
 
-/// Get a contract evaluation by ID.
-pub async fn get_contract_evaluation(
+/// List evaluations for a step.
+pub async fn list_step_evaluations(
     pool: &PgPool,
-    id: Uuid,
-) -> Result<Option<ContractEvaluation>, sqlx::Error> {
-    sqlx::query_as::<_, ContractEvaluation>(
-        r#"
-        SELECT *
-        FROM contract_evaluations
-        WHERE id = $1
-        "#,
+    step_id: Uuid,
+) -> Result<Vec<DirectiveEvaluation>, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveEvaluation>(
+        "SELECT * FROM directive_evaluations WHERE step_id = $1 ORDER BY evaluation_number DESC"
     )
-    .bind(id)
-    .fetch_optional(pool)
+    .bind(step_id)
+    .fetch_all(pool)
     .await
 }
 
-/// List evaluations for a contract.
-pub async fn list_contract_evaluations(
+/// List evaluations for a directive.
+pub async fn list_directive_evaluations(
     pool: &PgPool,
-    contract_id: Uuid,
-) -> Result<Vec<ContractEvaluationSummary>, sqlx::Error> {
-    sqlx::query_as::<_, ContractEvaluationSummary>(
-        r#"
-        SELECT id, contract_id, evaluation_number, passed, overall_score, summary_feedback, created_at
-        FROM contract_evaluations
-        WHERE contract_id = $1
-        ORDER BY evaluation_number DESC
-        "#,
+    directive_id: Uuid,
+    limit: Option<i64>,
+) -> Result<Vec<DirectiveEvaluation>, sqlx::Error> {
+    let limit = limit.unwrap_or(100);
+    sqlx::query_as::<_, DirectiveEvaluation>(
+        "SELECT * FROM directive_evaluations WHERE directive_id = $1 ORDER BY created_at DESC LIMIT $2"
     )
-    .bind(contract_id)
+    .bind(directive_id)
+    .bind(limit)
     .fetch_all(pool)
     .await
 }
 
-/// List evaluations for a chain.
-pub async fn list_chain_evaluations(
+// =============================================================================
+// Directive Event Operations
+// =============================================================================
+
+/// Emit a directive event.
+pub async fn emit_directive_event(
     pool: &PgPool,
-    chain_id: Uuid,
-) -> Result<Vec<ContractEvaluationSummary>, sqlx::Error> {
-    sqlx::query_as::<_, ContractEvaluationSummary>(
+    directive_id: Uuid,
+    chain_id: Option<Uuid>,
+    step_id: Option<Uuid>,
+    event_type: &str,
+    severity: &str,
+    event_data: Option<serde_json::Value>,
+    actor_type: &str,
+    actor_id: Option<Uuid>,
+) -> Result<DirectiveEvent, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveEvent>(
         r#"
-        SELECT id, contract_id, evaluation_number, passed, overall_score, summary_feedback, created_at
-        FROM contract_evaluations
-        WHERE chain_id = $1
-        ORDER BY created_at DESC
+        INSERT INTO directive_events (
+            directive_id, chain_id, step_id, event_type, severity, event_data, actor_type, actor_id
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+        RETURNING *
         "#,
     )
+    .bind(directive_id)
     .bind(chain_id)
+    .bind(step_id)
+    .bind(event_type)
+    .bind(severity)
+    .bind(event_data)
+    .bind(actor_type)
+    .bind(actor_id)
+    .fetch_one(pool)
+    .await
+}
+
+/// List directive events.
+pub async fn list_directive_events(
+    pool: &PgPool,
+    directive_id: Uuid,
+    limit: Option<i64>,
+) -> Result<Vec<DirectiveEvent>, sqlx::Error> {
+    let limit = limit.unwrap_or(100);
+    sqlx::query_as::<_, DirectiveEvent>(
+        "SELECT * FROM directive_events WHERE directive_id = $1 ORDER BY created_at DESC LIMIT $2"
+    )
+    .bind(directive_id)
+    .bind(limit)
+    .fetch_all(pool)
+    .await
+}
+
+// =============================================================================
+// Directive Verifier Operations
+// =============================================================================
+
+/// Create a directive verifier.
+pub async fn create_directive_verifier(
+    pool: &PgPool,
+    directive_id: Uuid,
+    name: &str,
+    verifier_type: &str,
+    command: Option<&str>,
+    working_directory: Option<&str>,
+    auto_detect: bool,
+    detect_files: Vec<String>,
+    weight: f64,
+    required: bool,
+) -> Result<DirectiveVerifier, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveVerifier>(
+        r#"
+        INSERT INTO directive_verifiers (
+            directive_id, name, verifier_type, command, working_directory,
+            auto_detect, detect_files, weight, required
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+        RETURNING *
+        "#,
+    )
+    .bind(directive_id)
+    .bind(name)
+    .bind(verifier_type)
+    .bind(command)
+    .bind(working_directory)
+    .bind(auto_detect)
+    .bind(&detect_files)
+    .bind(weight)
+    .bind(required)
+    .fetch_one(pool)
+    .await
+}
+
+/// List verifiers for a directive.
+pub async fn list_directive_verifiers(
+    pool: &PgPool,
+    directive_id: Uuid,
+) -> Result<Vec<DirectiveVerifier>, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveVerifier>(
+        "SELECT * FROM directive_verifiers WHERE directive_id = $1 ORDER BY name"
+    )
+    .bind(directive_id)
     .fetch_all(pool)
     .await
 }
 
-/// Get the latest evaluation for a chain contract.
-pub async fn get_latest_chain_contract_evaluation(
+/// Update a directive verifier.
+pub async fn update_directive_verifier(
     pool: &PgPool,
-    chain_contract_id: Uuid,
-) -> Result<Option<ContractEvaluation>, sqlx::Error> {
-    sqlx::query_as::<_, ContractEvaluation>(
+    verifier_id: Uuid,
+    enabled: Option<bool>,
+    command: Option<&str>,
+    weight: Option<f64>,
+    required: Option<bool>,
+) -> Result<DirectiveVerifier, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveVerifier>(
         r#"
-        SELECT *
-        FROM contract_evaluations
-        WHERE chain_contract_id = $1
-        ORDER BY evaluation_number DESC
-        LIMIT 1
+        UPDATE directive_verifiers SET
+            enabled = COALESCE($2, enabled),
+            command = COALESCE($3, command),
+            weight = COALESCE($4, weight),
+            required = COALESCE($5, required),
+            updated_at = NOW()
+        WHERE id = $1
+        RETURNING *
         "#,
     )
-    .bind(chain_contract_id)
-    .fetch_optional(pool)
+    .bind(verifier_id)
+    .bind(enabled)
+    .bind(command)
+    .bind(weight)
+    .bind(required)
+    .fetch_one(pool)
     .await
 }
 
-/// Get the next evaluation number for a chain contract.
-pub async fn get_next_evaluation_number(
+/// Update verifier last run result.
+pub async fn update_verifier_result(
     pool: &PgPool,
-    chain_contract_id: Uuid,
-) -> Result<i32, sqlx::Error> {
-    let result: Option<(i32,)> = sqlx::query_as(
+    verifier_id: Uuid,
+    result: serde_json::Value,
+) -> Result<DirectiveVerifier, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveVerifier>(
         r#"
-        SELECT COALESCE(MAX(evaluation_number), 0) + 1 as next_number
-        FROM contract_evaluations
-        WHERE chain_contract_id = $1
+        UPDATE directive_verifiers SET last_run_at = NOW(), last_result = $2, updated_at = NOW()
+        WHERE id = $1
+        RETURNING *
         "#,
     )
-    .bind(chain_contract_id)
-    .fetch_optional(pool)
-    .await?;
+    .bind(verifier_id)
+    .bind(result)
+    .fetch_one(pool)
+    .await
+}
 
-    Ok(result.map(|(n,)| n).unwrap_or(1))
+// =============================================================================
+// Directive Approval Operations
+// =============================================================================
+
+/// Create an approval request.
+pub async fn create_approval_request(
+    pool: &PgPool,
+    directive_id: Uuid,
+    step_id: Option<Uuid>,
+    approval_type: &str,
+    description: &str,
+    context: Option<serde_json::Value>,
+    urgency: &str,
+    expires_at: Option<chrono::DateTime<Utc>>,
+) -> Result<DirectiveApproval, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveApproval>(
+        r#"
+        INSERT INTO directive_approvals (
+            directive_id, step_id, approval_type, description, context, urgency, expires_at
+        )
+        VALUES ($1, $2, $3, $4, $5, $6, $7)
+        RETURNING *
+        "#,
+    )
+    .bind(directive_id)
+    .bind(step_id)
+    .bind(approval_type)
+    .bind(description)
+    .bind(context)
+    .bind(urgency)
+    .bind(expires_at)
+    .fetch_one(pool)
+    .await
 }
 
-/// Update chain contract evaluation status.
-pub async fn update_chain_contract_evaluation_status(
+/// Resolve an approval request.
+pub async fn resolve_approval(
     pool: &PgPool,
-    chain_contract_id: Uuid,
+    approval_id: Uuid,
     status: &str,
-    evaluation_id: Option<Uuid>,
-    rework_feedback: Option<&str>,
-) -> Result<ChainContract, sqlx::Error> {
-    sqlx::query_as::<_, ChainContract>(
-        r#"
-        UPDATE chain_contracts SET
-            evaluation_status = $2,
-            last_evaluation_id = COALESCE($3, last_evaluation_id),
-            rework_feedback = COALESCE($4, rework_feedback),
-            evaluation_retry_count = CASE
-                WHEN $2 = 'rework' THEN evaluation_retry_count + 1
-                ELSE evaluation_retry_count
-            END,
-            rework_started_at = CASE
-                WHEN $2 = 'rework' THEN NOW()
-                ELSE rework_started_at
-            END
+    response: Option<&str>,
+    responded_by: Uuid,
+) -> Result<DirectiveApproval, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveApproval>(
+        r#"
+        UPDATE directive_approvals SET
+            status = $2,
+            response = $3,
+            responded_by = $4,
+            responded_at = NOW()
         WHERE id = $1
         RETURNING *
         "#,
     )
-    .bind(chain_contract_id)
+    .bind(approval_id)
     .bind(status)
-    .bind(evaluation_id)
-    .bind(rework_feedback)
+    .bind(response)
+    .bind(responded_by)
     .fetch_one(pool)
     .await
 }
 
-/// Mark a chain contract's original completion time (before rework).
-pub async fn mark_chain_contract_original_completion(
+/// List pending approvals for a directive.
+pub async fn list_pending_approvals(
     pool: &PgPool,
-    chain_contract_id: Uuid,
-) -> Result<(), sqlx::Error> {
-    sqlx::query(
+    directive_id: Uuid,
+) -> Result<Vec<DirectiveApproval>, sqlx::Error> {
+    sqlx::query_as::<_, DirectiveApproval>(
         r#"
-        UPDATE chain_contracts SET
-            original_completion_at = COALESCE(original_completion_at, NOW())
-        WHERE id = $1
+        SELECT * FROM directive_approvals
+        WHERE directive_id = $1 AND status = 'pending'
+        ORDER BY
+            CASE urgency
+                WHEN 'critical' THEN 1
+                WHEN 'high' THEN 2
+                WHEN 'normal' THEN 3
+                ELSE 4
+            END,
+            created_at
         "#,
     )
-    .bind(chain_contract_id)
-    .execute(pool)
-    .await?;
-    Ok(())
+    .bind(directive_id)
+    .fetch_all(pool)
+    .await
 }
 
-/// Get chain contract by contract ID.
-pub async fn get_chain_contract_by_contract_id(
+/// Get step by contract ID.
+pub async fn get_step_by_contract_id(
     pool: &PgPool,
     contract_id: Uuid,
-) -> Result<Option<ChainContract>, sqlx::Error> {
-    sqlx::query_as::<_, ChainContract>(
-        r#"
-        SELECT *
-        FROM chain_contracts
-        WHERE contract_id = $1
-        "#,
+) -> Result<Option<ChainStep>, sqlx::Error> {
+    sqlx::query_as::<_, ChainStep>(
+        "SELECT * FROM chain_steps WHERE contract_id = $1"
     )
     .bind(contract_id)
     .fetch_optional(pool)
@@ -6682,103 +6034,9 @@ pub async fn get_chain_contract_by_contract_id(
 }
 
 // =============================================================================
-// Init Chain (Directive-Driven Chain Creation)
+// Helper Functions
 // =============================================================================
 
-/// Initialize a directive-driven chain.
-/// Creates a directive contract and an empty chain linked to it.
-pub async fn init_chain_for_owner(
-    pool: &PgPool,
-    owner_id: Uuid,
-    req: InitChainRequest,
-) -> Result<InitChainResponse, sqlx::Error> {
-    // Create the directive contract
-    // Note: "directive" contract type uses the "specification" phases by default
-    let contract_req = CreateContractRequest {
-        name: format!("Directive: {}", truncate_string(&req.goal, 50)),
-        description: Some(req.goal.clone()),
-        contract_type: Some("specification".to_string()), // Directive uses spec workflow
-        template_id: None,
-        initial_phase: Some("research".to_string()),
-        phase_guard: Some(req.phase_guard),
-        autonomous_loop: Some(false),
-        local_only: Some(false),
-        auto_merge_local: Some(false),
-    };
-
-    let contract = create_contract_for_owner(pool, owner_id, contract_req).await?;
-
-    // Mark it as a chain directive
-    sqlx::query("UPDATE contracts SET is_chain_directive = true WHERE id = $1")
-        .bind(contract.id)
-        .execute(pool)
-        .await?;
-
-    // Build repositories list from request
-    let repositories = match (req.repository_url.as_ref(), req.local_path.as_ref()) {
-        (Some(url), _) => Some(vec![AddChainRepositoryRequest {
-            name: "Primary".to_string(),
-            repository_url: Some(url.clone()),
-            local_path: None,
-            source_type: "remote".to_string(),
-            is_primary: true,
-        }]),
-        (None, Some(path)) => Some(vec![AddChainRepositoryRequest {
-            name: "Primary".to_string(),
-            repository_url: None,
-            local_path: Some(path.clone()),
-            source_type: "local".to_string(),
-            is_primary: true,
-        }]),
-        (None, None) => None,
-    };
-
-    // Create the chain with directive contract reference
-    let chain_req = CreateChainRequest {
-        name: truncate_string(&req.goal, 100),
-        description: Some(req.goal),
-        repositories,
-        loop_enabled: Some(false),
-        loop_max_iterations: None,
-        loop_progress_check: None,
-        contracts: None,
-    };
-
-    let chain = create_chain_for_owner(pool, owner_id, chain_req).await?;
-
-    // Link directive contract to chain
-    sqlx::query(
-        r#"
-        UPDATE chains SET directive_contract_id = $2 WHERE id = $1;
-        UPDATE contracts SET spawned_chain_id = $1 WHERE id = $2;
-        "#,
-    )
-    .bind(chain.id)
-    .bind(contract.id)
-    .execute(pool)
-    .await?;
-
-    // Create empty directive document
-    create_chain_directive(
-        pool,
-        chain.id,
-        CreateChainDirectiveRequest {
-            requirements: Some(vec![]),
-            acceptance_criteria: Some(vec![]),
-            constraints: Some(vec![]),
-            external_dependencies: Some(vec![]),
-            source_type: Some("llm_generated".to_string()),
-        },
-    )
-    .await?;
-
-    Ok(InitChainResponse {
-        chain_id: chain.id,
-        directive_contract_id: contract.id,
-        supervisor_task_id: contract.supervisor_task_id,
-    })
-}
-
 /// Helper to truncate string to max length
 fn truncate_string(s: &str, max_len: usize) -> String {
     if s.len() <= max_len {