Real-time Agent Progress and User Control UI

// src-tauri/src/main.rs

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use tokio::task::JoinHandle;
use chrono::Utc; // For timestamps

// ... (existing imports like tauri, tauri_plugin_shell, serde)

// Define the AgentLog struct for event payload
// 🧠 Important: This struct must derive `Clone` and `serde::Serialize`
// for Tauri's event system to work correctly.
#[derive(Clone, serde::Serialize)]
struct AgentLog {
    card_id: String,
    agent_id: String,
    message: String,
    timestamp: String,
    log_type: String, // e.g., "info", "progress", "error", "status"
}

// ... (existing greet, create_worktree, switch_worktree commands)

// The `run_agent_task` command will be modified later to integrate state management.
// For now, let's just make it emit events.
// We are temporarily commenting out the `state` parameter to focus on event emission.
// It will be re-added in the next section.
#[tauri::command]
async fn run_agent_task_placeholder(
    app_handle: tauri::AppHandle, // Add this parameter to access Tauri's event system
    card_id: String,
    agent_id: String,
    task_description: String,
) -> Result<String, String> {
    // 📌 Key Idea: Use AppHandle to emit events from the backend to the frontend.
    // `emit_all` sends the event to all listening webview windows.

    // Emit a "starting" event
    app_handle.emit_all(
        "agent_log",
        &AgentLog {
            card_id: card_id.clone(),
            agent_id: agent_id.clone(),
            message: format!("[{}] Starting task: {}", agent_id, task_description),
            timestamp: Utc::now().to_rfc3339(),
            log_type: "info".to_string(),
        },
    ).map_err(|e| e.to_string())?;

    // Simulate agent work and progress
    for i in 1..=3 {
        let progress_message = format!("[{}] Working on step {}/3...", agent_id, i);
        app_handle.emit_all(
            "agent_log",
            &AgentLog {
                card_id: card_id.clone(),
                agent_id: agent_id.clone(),
                message: progress_message.clone(),
                timestamp: Utc::now().to_rfc3339(),
                log_type: "progress".to_string(),
            },
        ).map_err(|e| e.to_string())?;
        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await; // Simulate work
    }

    // Simulate modifying a worktree (from previous chapter)
    let worktree_path = format!("/tmp/kanbots_worktrees/{}/{}", card_id, agent_id);
    std::fs::create_dir_all(&worktree_path)
        .map_err(|e| format!("Failed to create worktree dir: {}", e))?;
    let file_content = format!("// Generated by {} for card {}\nconsole.log('Task completed!');", agent_id, card_id);
    let file_path = format!("{}/output.js", worktree_path);
    std::fs::write(&file_path, file_content)
        .map_err(|e| format!("Failed to write file to worktree: {}", e))?;

    app_handle.emit_all(
        "agent_log",
        &AgentLog {
            card_id: card_id.clone(),
            agent_id: agent_id.clone(),
            message: format!("[{}] Task completed successfully. File created: {}", agent_id, file_path),
            timestamp: Utc::now().to_rfc3339(),
            log_type: "info".to_string(),
        },
    ).map_err(|e| e.to_string())?;

    Ok(format!("Agent {} completed task for card {}", agent_id, card_id))
}

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![
            greet,
            create_worktree,
            switch_worktree,
            run_agent_task_placeholder // Register the temporary command
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

# src-tauri/Cargo.toml
[dependencies]
chrono = { version = "0.4", features = ["serde"] }
# ... other dependencies

# src-tauri/Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] } # Use "full" for convenience in tutorials
# ... other dependencies

// src-tauri/src/main.rs

// ... (existing imports)
use std::sync::atomic::{AtomicBool, Ordering}; // For atomic cancellation flag
use tokio::sync::Notify; // For pause/resume signaling

// Global state to track agent tasks and their control flags
// 🧠 Important: Mutexes are crucial for safely sharing mutable state across threads.
// Arc allows multiple ownership of the same data.
struct AgentStateManager {
    // Stores handles to the running agent tasks, allowing us to abort them.
    tasks: Mutex<HashMap<String, JoinHandle<()>>>, // Key: card_id-agent_id
    // Notify is used for pause/resume. When `notify.notified().await` is called,
    // it blocks until `notify.notify_one()` or `notify.notify_waiters()` is called.
    pause_notifies: Mutex<HashMap<String, Arc<Notify>>>,
    // AtomicBool is a simple, thread-safe flag for cancellation.
    cancel_flags: Mutex<HashMap<String, Arc<AtomicBool>>>,
}

impl AgentStateManager {
    fn new() -> Self {
        AgentStateManager {
            tasks: Mutex::new(HashMap::new()),
            pause_notifies: Mutex::new(HashMap::new()),
            cancel_flags: Mutex::new(HashMap::new()),
        }
    }

    // Add a new agent task's control primitives to the manager
    fn add_task(
        &self,
        key: String,
        handle: JoinHandle<()>,
        pause_notify: Arc<Notify>,
        cancel_flag: Arc<AtomicBool>,
    ) {
        self.tasks.lock().unwrap().insert(key.clone(), handle);
        self.pause_notifies.lock().unwrap().insert(key.clone(), pause_notify);
        self.cancel_flags.lock().unwrap().insert(key, cancel_flag);
    }

    // Signal an agent task to cancel
    fn signal_cancel(&self, key: &str) -> bool {
        if let Some(flag) = self.cancel_flags.lock().unwrap().get(key) {
            flag.store(true, Ordering::SeqCst); // Set the cancellation flag
            // ⚡ Quick Note: Aborting the JoinHandle is a best-effort, non-graceful stop.
            // The AtomicBool provides a graceful exit path for the agent task itself.
            if let Some(handle) = self.tasks.lock().unwrap().remove(key) {
                handle.abort(); // Attempt to abort the Tokio task immediately
            }
            self.remove_task_entries(key);
            true
        } else {
            false
        }
    }

    // Signal an agent task to pause
    fn signal_pause(&self, key: &str) -> bool {
        if let Some(notify) = self.pause_notifies.lock().unwrap().get(key) {
            // ⚠️ What can go wrong: `Notify` does not inherently "pause" a task.
            // It unblocks tasks that are `await`ing on it. To pause, the agent task
            // itself must check a state and then `await notify.notified()` when paused.
            // For now, we'll just log this as a signal. The agent task logic needs to implement the actual waiting.
            println!("Signaling PAUSE for agent: {}", key);
            // We don't call notify_one() here, as that would *unpause* a waiting task.
            // The agent task will detect the pause state and then wait on the notify.
            true
        } else {
            false
        }
    }

    // Signal an agent task to resume
    fn signal_resume(&self, key: &str) -> bool {
        if let Some(notify) = self.pause_notifies.lock().unwrap().get(key) {
            notify.notify_one(); // Unblocks one task waiting on this notify
            println!("Signaling RESUME for agent: {}", key);
            true
        } else {
            false
        }
    }

    // Helper to remove all entries for a task after completion or cancellation
    fn remove_task_entries(&self, key: &str) {
        self.tasks.lock().unwrap().remove(key);
        self.pause_notifies.lock().unwrap().remove(key);
        self.cancel_flags.lock().unwrap().remove(key);
    }
}

// Make AgentStateManager available globally via Tauri's managed state
// ⚡ Real-world insight: Tauri's `manage` allows you to inject shared, immutable
// references to state into your command functions.
#[derive(Default)]
struct AppState {
    agent_manager: AgentStateManager,
}

// Update main function to register our managed state
fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .manage(AppState::default()) // Register our state manager here
        .invoke_handler(tauri::generate_handler![
            greet,
            create_worktree,
            switch_worktree,
            run_agent_task, // This will be our new, updated command
            pause_agent,    // New command for pausing
            resume_agent,   // New command for resuming
            cancel_agent    // New command for canceling
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// New Tauri commands for control
#[tauri::command]
async fn pause_agent(
    card_id: String,
    agent_id: String,
    state: tauri::State<'_, AppState>, // Access managed state
) -> Result<(), String> {
    let key = format!("{}-{}", card_id, agent_id);
    if state.agent_manager.signal_pause(&key) {
        Ok(())
    } else {
        Err(format!("Agent {} not found or not running.", key))
    }
}

#[tauri::command]
async fn resume_agent(
    card_id: String,
    agent_id: String,
    state: tauri::State<'_, AppState>,
) -> Result<(), String> {
    let key = format!("{}-{}", card_id, agent_id);
    if state.agent_manager.signal_resume(&key) {
        Ok(())
    } else {
        Err(format!("Agent {} not found or not running.", key))
    }
}

#[tauri::command]
async fn cancel_agent(
    card_id: String,
    agent_id: String,
    state: tauri::State<'_, AppState>,
) -> Result<(), String> {
    let key = format!("{}-{}", card_id, agent_id);
    if state.agent_manager.signal_cancel(&key) {
        Ok(())
    } else {
        Err(format!("Agent {} not found or not running.", key))
    }
}

// Modify run_agent_task to register its task and check for cancellation/pause
// This replaces the `run_agent_task_placeholder` from the previous step.
#[tauri::command]
async fn run_agent_task(
    app_handle: tauri::AppHandle,
    state: tauri::State<'_, AppState>, // Access managed state
    card_id: String,
    agent_id: String,
    task_description: String,
) -> Result<String, String> {
    let task_key = format!("{}-{}", card_id, agent_id);
    let cancel_flag = Arc::new(AtomicBool::new(false));
    let pause_notify = Arc::new(Notify::new());

    // Clone Arc for the spawned task and for the manager
    let cancel_flag_for_task = cancel_flag.clone();
    let pause_notify_for_task = pause_notify.clone();
    let app_handle_for_task = app_handle.clone();
    let card_id_for_task = card_id.clone();
    let agent_id_for_task = agent_id.clone();
    let state_for_task = state.clone(); // Clone the state for task cleanup

    // Spawn the agent logic into a separate Tokio task
    let handle = tokio::spawn(async move {
        // Initial status update
        app_handle_for_task.emit_all(
            "agent_log",
            &AgentLog {
                card_id: card_id_for_task.clone(),
                agent_id: agent_id_for_task.clone(),
                message: format!("[{}] Starting task: {}", agent_id_for_task, task_description),
                timestamp: Utc::now().to_rfc3339(),
                log_type: "status_running".to_string(), // Specific status type
            },
        ).unwrap_or_else(|e| eprintln!("Error emitting log: {}", e));


        for i in 1..=5 { // More steps to better demonstrate pause/cancel
            // Check for cancellation signal
            if cancel_flag_for_task.load(Ordering::SeqCst) {
                app_handle_for_task.emit_all(
                    "agent_log",
                    &AgentLog {
                        card_id: card_id_for_task.clone(),
                        agent_id: agent_id_for_task.clone(),
                        message: format!("[{}] Task cancelled by user.", agent_id_for_task),
                        timestamp: Utc::now().to_rfc3339(),
                        log_type: "status_cancelled".to_string(),
                    },
                ).unwrap_or_else(|e| eprintln!("Error emitting log: {}", e));
                state_for_task.agent_manager.remove_task_entries(&task_key); // Clean up
                return; // Exit the task gracefully
            }

            // ⚠️ What can go wrong: Implementing true pause.
            // To truly pause, the agent task needs to `await pause_notify_for_task.notified().await;`
            // when a pause signal is received. For this demonstration, we'll simulate a pause point
            // and emit a log, but not actually block the task.
            // A full implementation would involve a shared `AtomicBool` for `is_paused` and the `Notify`
            // to release the task from its waiting state.
            if i == 3 {
                 app_handle_for_task.emit_all(
                    "agent_log",
                    &AgentLog {
                        card_id: card_id_for_task.clone(),
                        agent_id: agent_id_for_task.clone(),
                        message: format!("[{}] Simulating potential pause point.", agent_id_for_task),
                        timestamp: Utc::now().to_rfc3339(),
                        log_type: "info".to_string(),
                    },
                ).unwrap_or_else(|e| eprintln!("Error emitting log: {}", e));
                // In a production system, a pause would look like:
                // if is_paused_flag.load(Ordering::SeqCst) {
                //     app_handle_for_task.emit_all("agent_log", ... "status_paused")...;
                //     pause_notify_for_task.notified().await; // Blocks until resumed
                //     app_handle_for_task.emit_all("agent_log", ... "status_running")...;
                // }
            }

            let progress_message = format!("[{}] Working on step {}/5...", agent_id_for_task, i);
            app_handle_for_task.emit_all(
                "agent_log",
                &AgentLog {
                    card_id: card_id_for_task.clone(),
                    agent_id: agent_id_for_task.clone(),
                    message: progress_message.clone(),
                    timestamp: Utc::now().to_rfc3339(),
                    log_type: "progress".to_string(),
                },
            ).unwrap_or_else(|e| eprintln!("Error emitting log: {}", e));
            tokio::time::sleep(tokio::time::Duration::from_secs(1)).await; // Simulate work
        }

        // Simulate modifying a worktree
        let worktree_path = format!("/tmp/kanbots_worktrees/{}/{}", card_id_for_task, agent_id_for_task);
        std::fs::create_dir_all(&worktree_path)
            .unwrap_or_else(|e| eprintln!("Failed to create worktree dir: {}", e));
        let file_content = format!("// Generated by {} for card {}\nconsole.log('Task completed!');", agent_id_for_task, card_id_for_task);
        let file_path = format!("{}/output.js", worktree_path);
        std::fs::write(&file_path, file_content)
            .unwrap_or_else(|e| eprintln!("Failed to write file to worktree: {}", e));

        app_handle_for_task.emit_all(
            "agent_log",
            &AgentLog {
                card_id: card_id_for_task.clone(),
                agent_id: agent_id_for_task.clone(),
                message: format!("[{}] Task completed successfully. File created: {}", agent_id_for_task, file_path),
                timestamp: Utc::now().to_rfc3339(),
                log_type: "status_completed".to_string(),
            },
        ).unwrap_or_else(|e| eprintln!("Error emitting log: {}", e));

        state_for_task.agent_manager.remove_task_entries(&task_key); // Clean up on completion
    });

    state.agent_manager.add_task(task_key, handle, pause_notify, cancel_flag);

    Ok(format!("Agent {} task started for card {}", agent_id, card_id))
}

<!-- src/lib/components/KanbanCard.svelte -->
<script lang="ts">
  import { createEventDispatcher, onMount, onDestroy } from 'svelte';
  import { invoke } from '@tauri-apps/api/core';
  import { listen } from '@tauri-apps/api/event';
  import type { Agent, KanbanCard as CardType } from '../types'; // Alias KanbanCard to avoid conflict
  import { cardStore } from '../stores'; // Assuming you have a store for cards

  export let card: CardType; // Use the aliased type
  export let columnId: string;

  const dispatch = createEventDispatcher();

  // Stores logs per agent
  let agentLogs: { [agentId: string]: { message: string; timestamp: string; log_type: string }[] } = {};
  // Stores current status per agent
  let agentStatuses: { [agentId: string]: 'idle' | 'running' | 'paused' | 'cancelled' | 'completed' | 'error' } = {};

  // Function to scroll logs to the bottom
  function scrollToBottom(agentId: string) {
    const logContainer = document.querySelector(`.log-output-${agentId}`);
    if (logContainer) {
      logContainer.scrollTop = logContainer.scrollHeight;
    }
  }

  onMount(async () => {
    // Listen for agent log events
    const unlisten = await listen<{ card_id: string; agent_id: string; message: string; timestamp: string; log_type: string }>(
      'agent_log',
      (event) => {
        const { card_id, agent_id, message, timestamp, log_type } = event.payload;
        if (card_id === card.id) {
          if (!agentLogs[agent_id]) {
            agentLogs[agent_id] = [];
          }
          agentLogs[agent_id] = [...agentLogs[agent_id], { message, timestamp, log_type }];
          
          // Update status based on specific log types
          if (log_type === 'status_running') {
            agentStatuses[agent_id] = 'running';
          } else if (log_type === 'status_cancelled') {
            agentStatuses[agent_id] = 'cancelled';
          } else if (log_type === 'status_completed') {
            agentStatuses[agent_id] = 'completed';
          } else if (log_type === 'error') {
             // If an error log comes in, and not already cancelled/completed, set to error
            if (!['cancelled', 'completed'].includes(agentStatuses[agent_id])) {
                agentStatuses[agent_id] = 'error';
            }
          }
          // The pause/resume status will be updated on command invocation, not log type
          
          agentLogs = agentLogs; // Trigger Svelte reactivity
          agentStatuses = agentStatuses; // Trigger Svelte reactivity
          
          // Scroll to bottom after updates
          setTimeout(() => scrollToBottom(agent_id), 0);
        }
      }
    );

    onDestroy(() => {
      unlisten();
    });
  });

  async function runAgent(agentId: string, taskDescription: string) {
    try {
      agentStatuses[agentId] = 'running';
      agentLogs[agentId] = []; // Clear previous logs for a new run
      agentLogs = agentLogs;
      agentStatuses = agentStatuses;
      await invoke('run_agent_task', { cardId: card.id, agentId, taskDescription });
    } catch (error) {
      console.error('Error running agent:', error);
      agentLogs[agentId] = [...(agentLogs[agentId] || []), { message: `Error: ${error}`, timestamp: new Date().toISOString(), log_type: 'error' }];
      agentStatuses[agentId] = 'error';
      agentLogs = agentLogs;
      agentStatuses = agentStatuses;
    }
  }

  async function pauseAgent(agentId: string) {
    try {
      await invoke('pause_agent', { cardId: card.id, agentId });
      agentStatuses[agentId] = 'paused'; // Optimistic UI update
      agentLogs[agentId] = [...(agentLogs[agentId] || []), { message: `[${agentId}] Pause signal sent.`, timestamp: new Date().toISOString(), log_type: 'info' }];
      agentStatuses = agentStatuses;
      agentLogs = agentLogs;
    } catch (error) {
      console.error('Error pausing agent:', error);
      agentLogs[agentId] = [...(agentLogs[agentId] || []), { message: `Error pausing: ${error}`, timestamp: new Date().toISOString(), log_type: 'error' }];
      agentLogs = agentLogs;
    }
  }

  async function resumeAgent(agentId: string) {
    try {
      await invoke('resume_agent', { cardId: card.id, agentId });
      agentStatuses[agentId] = 'running'; // Optimistic UI update
      agentLogs[agentId] = [...(agentLogs[agentId] || []), { message: `[${agentId}] Resume signal sent.`, timestamp: new Date().toISOString(), log_type: 'info' }];
      agentStatuses = agentStatuses;
      agentLogs = agentLogs;
    } catch (error) {
      console.error('Error resuming agent:', error);
      agentLogs[agentId] = [...(agentLogs[agentId] || []), { message: `Error resuming: ${error}`, timestamp: new Date().toISOString(), log_type: 'error' }];
      agentLogs = agentLogs;
    }
  }

  async function cancelAgent(agentId: string) {
    try {
      await invoke('cancel_agent', { cardId: card.id, agentId });
      agentStatuses[agentId] = 'cancelled'; // Optimistic UI update
      agentLogs[agentId] = [...(agentLogs[agentId] || []), { message: `[${agentId}] Cancel signal sent.`, timestamp: new Date().toISOString(), log_type: 'error' }];
      agentStatuses = agentStatuses;
      agentLogs = agentLogs;
    } catch (error) {
      console.error('Error canceling agent:', error);
      agentLogs[agentId] = [...(agentLogs[agentId] || []), { message: `Error canceling: ${error}`, timestamp: new Date().toISOString(), log_type: 'error' }];
      agentLogs = agentLogs;
    }
  }

  // ... (existing drag/drop handlers, if any)
</script>

<div class="kanban-card" draggable="true" on:dragstart on:dragend>
  <h3>{card.title}</h3>
  <p>{card.description}</p>

  {#each card.agents as agent (agent.id)}
    <div class="agent-section">
      <h4>Agent: {agent.name} ({agent.persona})</h4>
      <p>Status: <span class="agent-status status-{agentStatuses[agent.id] || 'idle'}">{agentStatuses[agent.id] || 'idle'}</span></p>
      <div class="agent-controls">
        {#if agentStatuses[agent.id] === 'running'}
          <button on:click={() => pauseAgent(agent.id)}>Pause</button>
          <button on:click={() => cancelAgent(agent.id)}>Cancel</button>
        {:else if agentStatuses[agent.id] === 'paused'}
          <button on:click={() => resumeAgent(agent.id)}>Resume</button>
          <button on:click={() => cancelAgent(agent.id)}>Cancel</button>
        {:else if ['idle', 'completed', 'cancelled', 'error'].includes(agentStatuses[agent.id]) || !agentStatuses[agent.id]}
          <button on:click={() => runAgent(agent.id, `Develop feature for card ${card.id}`)}>Run Agent</button>
        {/if}
      </div>
      <div class="agent-logs">
        <h5>Logs:</h5>
        <div class="log-output log-output-{agent.id}">
          {#each agentLogs[agent.id] || [] as log}
            <p class="log-entry log-{log.log_type}">
              [{new Date(log.timestamp).toLocaleTimeString()}] {log.message}
            </p>
          {/each}
        </div>
      </div>
    </div>
  {/each}

  <!-- ... (existing card content) -->
</div>

<style>
  /* Add basic styling for the new elements */
  .kanban-card {
    background-color: white;
    padding: 15px;
    border-radius: 8px;
    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
    margin-bottom: 10px;
    cursor: grab;
  }
  .agent-section {
    margin-top: 15px;
    padding-top: 10px;
    border-top: 1px solid #eee;
  }
  .agent-controls button {
    margin-right: 5px;
    padding: 5px 10px;
    border-radius: 4px;
    border: 1px solid #ccc;
    background-color: #f0f0f0;
    cursor: pointer;
  }
  .agent-controls button:hover {
    background-color: #e0e0e0;
  }
  .agent-logs {
    margin-top: 10px;
    max-height: 150px; /* Limit height for scrollability */
    overflow-y: auto;
    background-color: #f9f9f9;
    border: 1px solid #ddd;
    padding: 8px;
    border-radius: 4px;
    font-family: monospace;
    font-size: 0.85em;
  }
  .log-output p {
    margin: 0;
    line-height: 1.4;
  }
  /* Specific log type styling */
  .log-error {
    color: red;
    font-weight: bold;
  }
  .log-progress {
    color: #007bff; /* Blue for progress */
  }
  .log-status_running {
    color: green;
  }
  .log-status_completed {
    color: darkgreen;
  }
  .log-status_cancelled {
    color: orange;
    font-weight: bold;
  }

  /* Agent status badge styling */
  .agent-status {
      padding: 2px 6px;
      border-radius: 4px;
      font-weight: bold;
      font-size: 0.8em;
      text-transform: uppercase;
  }
  .status-idle { background-color: #e0e0e0; color: #555; }
  .status-running { background-color: #d4edda; color: #155724; }
  .status-paused { background-color: #fff3cd; color: #856404; }
  .status-cancelled { background-color: #f8d7da; color: #721c24; }
  .status-completed { background-color: #cce5ff; color: #004085; }
  .status-error { background-color: #f8d7da; color: #721c24; }
</style>

// src/lib/types.ts

export interface Agent {
  id: string;
  name: string;
  persona: string;
  // Add other agent properties as needed
}

export interface KanbanCard {
  id: string;
  title: string;
  description: string;
  columnId: string;
  agents: Agent[]; // Ensure agents array is part of the card
  // Add other card properties as needed
}

export interface KanbanColumn {
  id: string;
  title: string;
  cardIds: string[];
}

// src/lib/stores.ts

import { writable } from 'svelte/store';
import type { KanbanCard, KanbanColumn } from './types';

// Initial dummy data for demonstration
const initialCards: KanbanCard[] = [
  { id: 'card-1', title: 'Implement User Auth', description: 'Setup JWT authentication for API endpoints.', columnId: 'todo',
    agents: [
      { id: 'agent-1-dev', name: 'Claude Code Dev', persona: 'Developer' },
      { id: 'agent-1-rev', name: 'Codex Reviewer', persona: 'Code Reviewer' },
    ]
  },
  { id: 'card-2', title: 'Design Database Schema', description: 'Outline tables and relationships for user data.', columnId: 'in-progress',
    agents: [
      { id: 'agent-2-arch', name: 'Claude Code Architect', persona: 'Architect' },
    ]
  },
  { id: 'card-3', title: 'Refactor Legacy Module', description: 'Improve readability and performance of old code.', columnId: 'todo',
    agents: [
      { id: 'agent-3-opt', name: 'Codex Optimizer', persona: 'Refactorer' },
    ]
  },
];

const initialColumns: KanbanColumn[] = [
  { id: 'todo', title: 'To Do', cardIds: ['card-1', 'card-3'] },
  { id: 'in-progress', title: 'In Progress', cardIds: ['card-2'] },
  { id: 'done', title: 'Done', cardIds: [] },
];

export const cardStore = writable<KanbanCard[]>(initialCards);
export const columnStore = writable<KanbanColumn[]>(initialColumns);